From 7a971eb3356679e27ddf03444398eb8554d062d3 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:31:29 +0100 Subject: [PATCH 01/23] feat(linux-sidebar): add a Favorites scope listing the connection's saved queries --- linux/crates/app/src/ui/workspace/mod.rs | 7 + .../ui/workspace/sidebar/favorites_pane.rs | 133 ++++++++++++++++++ .../app/src/ui/workspace/sidebar/mod.rs | 2 + .../app/src/ui/workspace/status_pages.rs | 31 +++- .../app/src/ui/workspace/workspace_shell.rs | 75 +++++++++- .../src/ui/workspace/workspace_shell_imp.rs | 10 ++ linux/data/resources/ui/workspace-shell.ui | 24 ++++ 7 files changed, 279 insertions(+), 3 deletions(-) create mode 100644 linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 6e4edd63b6..429e700d83 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -546,6 +546,8 @@ pub(crate) enum WorkspaceInput { ShowHistory, ShowSavedQueries, ActiveTab(workspace_tabs::ActiveTabCommand), + /// A query was saved or replaced: the sidebar's favorites read again. + SavedQueriesChanged, SaveQueryNamed { name: String, query: String, @@ -1406,6 +1408,11 @@ impl WorkspaceModel { WorkspaceInput::ImportCsvRun(import) => self.on_import_csv_run(*import), WorkspaceInput::ActiveTab(command) => self.on_active_tab_command(command), WorkspaceInput::SaveQueryNamed { name, query } => self.on_save_query_named(name, query), + WorkspaceInput::SavedQueriesChanged => { + if let Some(shell) = self.shell.upgrade() { + shell.reload_favorites(); + } + } WorkspaceInput::OpenHistoryQuery(text) => self.open_editor_tab(Some(text)), WorkspaceInput::ReplaceActiveTabQuery(text) => self.on_replace_active_tab_query(text), WorkspaceInput::RefreshPage => self.on_refresh_active_tab(), diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs new file mode 100644 index 0000000000..63edde2377 --- /dev/null +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -0,0 +1,133 @@ +//! The sidebar's Favorites scope: the named queries the user kept for the +//! connection in front, as the macOS sidebar lists them beside its +//! tables. Activating one opens it in a new query tab. + +use std::rc::Rc; + +use gtk4 as gtk; +use gtk4::prelude::*; +use gtk4::{gio, glib}; +use libadwaita as adw; +use tablepro_storage::saved_queries::SavedQuery; + +use crate::i18n::gettext; + +const LIST: &str = "list"; +const EMPTY: &str = "empty"; + +/// What activating a favorite asks for: its SQL. +type Opened = Rc; + +#[derive(Clone)] +pub(crate) struct FavoritesPane { + stack: gtk::Stack, + store: gio::ListStore, +} + +impl FavoritesPane { + pub(crate) fn new(opened: impl Fn(String) + 'static) -> Self { + let store = gio::ListStore::new::(); + let selection = gtk::SingleSelection::builder() + .model(&store) + .autoselect(false) + .can_unselect(true) + .build(); + let list = gtk::ListView::new(Some(selection), Some(factory())); + list.add_css_class("navigation-sidebar"); + list.set_single_click_activate(true); + list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); + let opened: Opened = Rc::new(opened); + let model = store.clone(); + list.connect_activate(move |_, position| { + if let Some(favorite) = favorite_at(&model, position) { + opened(favorite.query); + } + }); + let scrolled = gtk::ScrolledWindow::builder() + .hscrollbar_policy(gtk::PolicyType::Never) + .child(&list) + .build(); + let empty = adw::StatusPage::builder() + .title(gettext("No Favorites")) + .description(gettext("Save a query from the SQL editor to find it here.")) + .build(); + empty.add_css_class("compact"); + let stack = gtk::Stack::new(); + stack.add_named(&scrolled, Some(LIST)); + stack.add_named(&empty, Some(EMPTY)); + stack.set_visible_child_name(EMPTY); + Self { stack, store } + } + + pub(crate) fn widget(&self) -> gtk::Widget { + self.stack.clone().upcast() + } + + /// List `favorites`, the newest save first. + pub(crate) fn show(&self, mut favorites: Vec) { + favorites.sort_by(|a, b| b.updated_at.cmp(&a.updated_at)); + let items: Vec = favorites.into_iter().map(glib::BoxedAnyObject::new).collect(); + self.store.splice(0, self.store.n_items(), &items); + self.stack + .set_visible_child_name(if items.is_empty() { EMPTY } else { LIST }); + } + + #[cfg(test)] + pub(crate) fn names(&self) -> Vec { + (0..self.store.n_items()) + .filter_map(|position| favorite_at(&self.store, position)) + .map(|favorite| favorite.name) + .collect() + } +} + +fn favorite_at(store: &gio::ListStore, position: u32) -> Option { + let item = store.item(position).and_downcast::()?; + Some(item.borrow::().clone()) +} + +fn factory() -> gtk::SignalListItemFactory { + let factory = gtk::SignalListItemFactory::new(); + factory.connect_setup(|_, item| { + let Some(item) = item.downcast_ref::() else { + return; + }; + let name = gtk::Label::builder() + .xalign(0.0) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + let summary = gtk::Label::builder() + .xalign(0.0) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + summary.add_css_class("caption"); + summary.add_css_class("dimmed"); + let row = gtk::Box::builder() + .orientation(gtk::Orientation::Vertical) + .spacing(2) + .margin_top(6) + .margin_bottom(6) + .build(); + row.append(&name); + row.append(&summary); + item.set_child(Some(&row)); + }); + factory.connect_bind(|_, item| { + let Some(item) = item.downcast_ref::() else { + return; + }; + let (Some(object), Some(row)) = (item.item().and_downcast::(), item.child()) else { + return; + }; + let favorite = object.borrow::().clone(); + if let (Some(name), Some(summary)) = ( + row.first_child().and_downcast::(), + row.last_child().and_downcast::(), + ) { + name.set_label(&favorite.name); + summary.set_label(favorite.summary()); + } + item.set_accessible_label(&favorite.name); + }); + factory +} diff --git a/linux/crates/app/src/ui/workspace/sidebar/mod.rs b/linux/crates/app/src/ui/workspace/sidebar/mod.rs index 9c886343cf..92964f54ab 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/mod.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/mod.rs @@ -4,6 +4,7 @@ mod catalog_watch; mod connection_tree; +mod favorites_pane; mod key_listing; mod object_key; mod object_target; @@ -35,6 +36,7 @@ use tablepro_session::{ObjectListSnapshot, Session}; pub(super) use catalog_watch::{catalog_watch, reconnect_watch, spawn_local}; pub(crate) use connection_tree::{ConnectionTree, SessionRowState}; +pub(crate) use favorites_pane::FavoritesPane; pub(crate) use key_listing::{KeySidebar, KeysListed}; pub(super) use sidebar_affordances::SidebarAffordances; use sidebar_index::SidebarIndex; diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index ee669cee91..a091fa941c 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -161,8 +161,13 @@ impl WorkspaceModel { return; }; let message = match store.save(new_query).await { - Ok(outcome) if outcome.replaced => crate::i18n::gettext_f("Replaced “{name}”.", &[("name", &name)]), - Ok(_) => crate::i18n::gettext_f("Saved “{name}”.", &[("name", &name)]), + Ok(outcome) => { + input.deliver(WorkspaceInput::SavedQueriesChanged); + match outcome.replaced { + true => crate::i18n::gettext_f("Replaced “{name}”.", &[("name", &name)]), + false => crate::i18n::gettext_f("Saved “{name}”.", &[("name", &name)]), + } + } Err(error) => { tracing::warn!(%error, "could not save the query"); crate::i18n::gettext("Could not save that query.") @@ -224,6 +229,28 @@ mod tests { ); } + /// The Favorites scope lists the front connection's saved queries, and + /// reads them again when one is saved. + #[gtk4::test] + fn the_favorites_scope_lists_the_saved_queries_of_the_front_connection() { + use gtk4::prelude::*; + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let test = TestWindow::connected("FavoritesScope"); + let history = test.services.history(); + let availability = history.availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("the query database to open"); + let shell = test.window.shell().expect("the shell"); + let favorites = shell.imp().favorites.get().cloned().expect("the favorites pane"); + + shell.imp().scope_toggle.set_active_name(Some("favorites")); + assert!(favorites.names().is_empty(), "nothing is saved yet"); + + test.workspace() + .with_model(|model| model.on_save_query_named("Orders".to_owned(), "SELECT 1".to_owned())); + wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); + } + #[gtk4::test] fn a_history_dialog_closed_by_hand_is_not_closed_again_on_disconnect() { use gtk4::glib; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 25eb2ae449..35188fda76 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -11,6 +11,7 @@ use gtk4::subclass::prelude::*; use libadwaita as adw; use libadwaita::prelude::BinExt; use tablepro_core::DataModel; +use tablepro_session::SessionKey; use uuid::Uuid; use super::health_banner::REVIEW_HOST_KEY; @@ -28,6 +29,10 @@ use crate::ui::shell::{PRIMARY_MENU, TAB_OVERVIEW_MENU, app_menu, primary_menu_b /// names it. pub(super) const SHOW_SIDEBAR: &str = "show-sidebar"; +/// The sidebar's two lists, which its scope switch names. +const TABLES: &str = "tables"; +const FAVORITES: &str = "favorites"; + /// The window action that shows and hides the assistant's column. pub(super) const SHOW_ASSISTANT: &str = "show-assistant"; @@ -86,7 +91,23 @@ impl WorkspaceShell { let imp = shell.imp(); imp.window.set(Some(window)); let tree = ConnectionTree::new(services.saved_connections.clone()); - imp.sidebar_slot.set_child(Some(&tree.widget())); + let sidebar = gtk::Stack::new(); + sidebar.add_named(&tree.widget(), Some(TABLES)); + let favorites = super::sidebar::FavoritesPane::new(glib::clone!( + #[weak] + shell, + move |sql| shell.open_favorite(sql) + )); + sidebar.add_named(&favorites.widget(), Some(FAVORITES)); + imp.sidebar_slot.set_child(Some(&sidebar)); + let _ = imp.sidebar_stack.set(sidebar); + let _ = imp.favorites.set(favorites); + let _ = imp.favorites_source.set((services.history(), services.tasks.clone())); + imp.scope_toggle.connect_active_name_notify(glib::clone!( + #[weak] + shell, + move |_| shell.on_scope_changed() + )); tree.follow_search(&imp.table_search); let _ = imp.tree.set(tree); crate::ui::picker::install_picker_actions(&shell, services.saved_connections.clone(), sender.clone()); @@ -534,6 +555,57 @@ impl WorkspaceShell { /// Show the front's banners and assistant, and name what follows its /// data model after it. The expressions of `bind_front` do the rest. + /// The sidebar shows its tables or its favorites. + fn on_scope_changed(&self) { + let imp = self.imp(); + let favorites = imp.scope_toggle.active_name().as_deref() == Some(FAVORITES); + if let Some(stack) = imp.sidebar_stack.get() { + stack.set_visible_child_name(if favorites { FAVORITES } else { TABLES }); + } + // The search reads connections and tables, which this scope does not list. + imp.table_search_toggle.set_visible(!favorites); + self.reload_favorites(); + } + + /// Read the front session's favorites again, while they are shown. + pub(crate) fn reload_favorites(&self) { + let imp = self.imp(); + if imp.scope_toggle.active_name().as_deref() != Some(FAVORITES) { + return; + } + let (Some(pane), Some((history, tasks))) = (imp.favorites.get().cloned(), imp.favorites_source.get()) else { + return; + }; + let connection = self.front().and_then(|front| front.key()).and_then(|key| match key { + SessionKey::Saved(id) | SessionKey::SavedIn { id, .. } => Some(id), + SessionKey::File(_) => None, + }); + let Some(connection) = connection else { + pane.show(Vec::new()); + return; + }; + let ready = history.ready_store(); + crate::runtime::spawn_and_deliver( + tasks, + async move { + let store = ready.await?.saved_queries(); + store.list(Some(connection)).await.ok() + }, + move |listed| { + if let Ok(Some(favorites)) = listed { + pane.show(favorites); + } + }, + ); + } + + /// A favorite was picked: its SQL opens in a new query tab of the front session. + fn open_favorite(&self, sql: String) { + if let Some(sender) = self.front().and_then(|front| front.sender()) { + sender.deliver(super::WorkspaceInput::OpenHistoryQuery(sql)); + } + } + fn on_front_changed(&self) { let imp = self.imp(); if let Some(front) = self.front() { @@ -551,6 +623,7 @@ impl WorkspaceShell { } } self.describe_front(); + self.reload_favorites(); self.sync_assistant_column(); self.follow_front_for_new_tabs(); // A front with a tab selected says which row it shows itself. diff --git a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs index 0b88179f47..9ddd146323 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs @@ -65,6 +65,8 @@ pub struct WorkspaceShell { #[template_child] pub sidebar_slot: TemplateChild, #[template_child] + pub scope_toggle: TemplateChild, + #[template_child] pub assistant_split: TemplateChild, #[template_child] pub assistant_stack: TemplateChild, @@ -114,6 +116,14 @@ pub struct WorkspaceShell { /// The saved connections, and the schemas and tables of each one open /// in the window. pub(super) tree: OnceCell, + /// The sidebar's lists: the tree, and the favorites of the front session. + pub(super) sidebar_stack: OnceCell, + pub(super) favorites: OnceCell, + /// Where the favorites are read from, and the runtime that reads them. + pub(super) favorites_source: OnceCell<( + crate::services::history_service::HistoryService, + tablepro_session::runtime::Tasks, + )>, /// The window the shell added its actions to. pub(super) window: glib::WeakRef, pub(super) sender: OnceCell>, diff --git a/linux/data/resources/ui/workspace-shell.ui b/linux/data/resources/ui/workspace-shell.ui index 040ecb5aee..7c4f3b5235 100644 --- a/linux/data/resources/ui/workspace-shell.ui +++ b/linux/data/resources/ui/workspace-shell.ui @@ -85,6 +85,30 @@ + + + + tables + true + 12 + 12 + 6 + 6 + + + tables + Tables + + + + + favorites + Favorites + + + + From d732f385bf3bfbaf4e029f72b4d77fa946f28938 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:33:06 +0100 Subject: [PATCH 02/23] docs(linux-sidebar): add the changelog entry --- linux/changelog.d/4114.added.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 linux/changelog.d/4114.added.md diff --git a/linux/changelog.d/4114.added.md b/linux/changelog.d/4114.added.md new file mode 100644 index 0000000000..0885e7d2fd --- /dev/null +++ b/linux/changelog.d/4114.added.md @@ -0,0 +1 @@ +The sidebar has a Favorites scope listing the saved queries of the connection in front. From 9dc6e682d636e0f26bbd54b33b2595f3a472bf40 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:43:57 +0100 Subject: [PATCH 03/23] test(linux-sidebar): drop an unused import --- linux/crates/app/src/ui/workspace/status_pages.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index a091fa941c..3f35d692f1 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -233,7 +233,6 @@ mod tests { /// reads them again when one is saved. #[gtk4::test] fn the_favorites_scope_lists_the_saved_queries_of_the_front_connection() { - use gtk4::prelude::*; use gtk4::subclass::prelude::ObjectSubclassIsExt; let test = TestWindow::connected("FavoritesScope"); From b1f892ea62984195c18d6a4c6a739386bbc4eac3 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:43:57 +0100 Subject: [PATCH 04/23] feat(linux-sidebar): rename and delete a favorite from the list --- .../ui/workspace/sidebar/favorites_pane.rs | 134 +++++++++++++++++- .../app/src/ui/workspace/sidebar/mod.rs | 2 +- .../app/src/ui/workspace/status_pages.rs | 23 +++ .../app/src/ui/workspace/workspace_shell.rs | 109 +++++++++++++- 4 files changed, 256 insertions(+), 12 deletions(-) diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 63edde2377..96f617ce68 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -15,8 +15,21 @@ use crate::i18n::gettext; const LIST: &str = "list"; const EMPTY: &str = "empty"; -/// What activating a favorite asks for: its SQL. -type Opened = Rc; +/// What the user asks of a favorite. +#[derive(Debug, Clone)] +pub(crate) enum FavoriteAction { + /// Open its SQL in a new query tab. + Open(String), + Rename(SavedQuery), + Delete(SavedQuery), +} + +type Asked = Rc; + +/// The class that marks a favorite's row, which carries its id as its name. +const ROW: &str = "favorite-row"; +const RENAME: &str = "rename"; +const DELETE: &str = "delete"; #[derive(Clone)] pub(crate) struct FavoritesPane { @@ -25,7 +38,7 @@ pub(crate) struct FavoritesPane { } impl FavoritesPane { - pub(crate) fn new(opened: impl Fn(String) + 'static) -> Self { + pub(crate) fn new(asked: impl Fn(FavoriteAction) + 'static) -> Self { let store = gio::ListStore::new::(); let selection = gtk::SingleSelection::builder() .model(&store) @@ -36,13 +49,15 @@ impl FavoritesPane { list.add_css_class("navigation-sidebar"); list.set_single_click_activate(true); list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); - let opened: Opened = Rc::new(opened); + let asked: Asked = Rc::new(asked); let model = store.clone(); + let open = asked.clone(); list.connect_activate(move |_, position| { if let Some(favorite) = favorite_at(&model, position) { - opened(favorite.query); + open(FavoriteAction::Open(favorite.query)); } }); + install_menu(&list, &store, &selection_of(&list), &asked); let scrolled = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) .child(&list) @@ -72,6 +87,14 @@ impl FavoritesPane { .set_visible_child_name(if items.is_empty() { EMPTY } else { LIST }); } + #[cfg(test)] + pub(crate) fn ids(&self) -> Vec { + (0..self.store.n_items()) + .filter_map(|position| favorite_at(&self.store, position)) + .map(|favorite| favorite.id) + .collect() + } + #[cfg(test)] pub(crate) fn names(&self) -> Vec { (0..self.store.n_items()) @@ -81,6 +104,105 @@ impl FavoritesPane { } } +fn selection_of(list: >k::ListView) -> gtk::SingleSelection { + list.model() + .and_downcast::() + .unwrap_or_else(|| gtk::SingleSelection::new(None::)) +} + +/// Rename and Delete, from a right click on a row or F2 and Delete on the +/// selected one. The menu names the row by its id, which no reload moves. +fn install_menu(list: >k::ListView, store: &gio::ListStore, selection: >k::SingleSelection, asked: &Asked) { + let find = { + let store = store.clone(); + move |id: i64| { + (0..store.n_items()) + .filter_map(|position| favorite_at(&store, position)) + .find(|favorite| favorite.id == id) + } + }; + let actions = gio::SimpleActionGroup::new(); + for (name, make) in [ + (RENAME, FavoriteAction::Rename as fn(SavedQuery) -> FavoriteAction), + (DELETE, FavoriteAction::Delete), + ] { + let action = gio::SimpleAction::new(name, Some(glib::VariantTy::INT64)); + let (find, asked) = (find.clone(), asked.clone()); + action.connect_activate(move |_, id| { + if let Some(favorite) = id.and_then(|id| id.get::()).and_then(&find) { + asked(make(favorite)); + } + }); + actions.add_action(&action); + } + list.insert_action_group("favorite", Some(&actions)); + + let popover = gtk::PopoverMenu::from_model(None::<&gio::MenuModel>); + popover.set_has_arrow(false); + popover.set_parent(list); + let click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_SECONDARY).build(); + { + let (list, store, popover) = (list.downgrade(), store.clone(), popover.clone()); + click.connect_pressed(move |gesture, _, x, y| { + let Some(list) = list.upgrade() else { + return; + }; + let Some(favorite) = row_at(&list, &store, x, y) else { + return; + }; + gesture.set_state(gtk::EventSequenceState::Claimed); + popover.set_menu_model(Some(&menu_of(favorite.id))); + popover.set_pointing_to(Some(>k::gdk::Rectangle::new(x as i32, y as i32, 1, 1))); + popover.popup(); + }); + } + list.add_controller(click); + // GTK finalizes a parent with a child left over and warns of it. + list.connect_destroy(move |_| popover.unparent()); + + let keys = gtk::EventControllerKey::new(); + let (selection, store, asked) = (selection.clone(), store.clone(), asked.clone()); + keys.connect_key_pressed(move |_, key, _, _| { + let Some(favorite) = favorite_at(&store, selection.selected()) else { + return glib::Propagation::Proceed; + }; + match key { + gtk::gdk::Key::F2 => asked(FavoriteAction::Rename(favorite)), + gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete => asked(FavoriteAction::Delete(favorite)), + _ => return glib::Propagation::Proceed, + } + glib::Propagation::Stop + }); + list.add_controller(keys); +} + +fn menu_of(id: i64) -> gio::Menu { + let menu = gio::Menu::new(); + for (label, action) in [(gettext("_Rename…"), RENAME), (gettext("_Delete…"), DELETE)] { + let item = gio::MenuItem::new(Some(&label), None); + item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&id.to_variant())); + menu.append_item(&item); + } + menu +} + +/// The favorite drawn at `(x, y)` in the list. Each row is named by its +/// favorite's id as it binds, so a row finds its favorite however the +/// list has scrolled and recycled. +fn row_at(list: >k::ListView, store: &gio::ListStore, x: f64, y: f64) -> Option { + let mut widget = list.pick(x, y, gtk::PickFlags::DEFAULT); + while let Some(candidate) = widget { + if candidate.has_css_class(ROW) { + let id: i64 = candidate.widget_name().parse().ok()?; + return (0..store.n_items()) + .filter_map(|position| favorite_at(store, position)) + .find(|favorite| favorite.id == id); + } + widget = candidate.parent(); + } + None +} + fn favorite_at(store: &gio::ListStore, position: u32) -> Option { let item = store.item(position).and_downcast::()?; Some(item.borrow::().clone()) @@ -108,6 +230,7 @@ fn factory() -> gtk::SignalListItemFactory { .margin_top(6) .margin_bottom(6) .build(); + row.add_css_class(ROW); row.append(&name); row.append(&summary); item.set_child(Some(&row)); @@ -120,6 +243,7 @@ fn factory() -> gtk::SignalListItemFactory { return; }; let favorite = object.borrow::().clone(); + row.set_widget_name(&favorite.id.to_string()); if let (Some(name), Some(summary)) = ( row.first_child().and_downcast::(), row.last_child().and_downcast::(), diff --git a/linux/crates/app/src/ui/workspace/sidebar/mod.rs b/linux/crates/app/src/ui/workspace/sidebar/mod.rs index 92964f54ab..03bdd795c7 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/mod.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/mod.rs @@ -36,7 +36,7 @@ use tablepro_session::{ObjectListSnapshot, Session}; pub(super) use catalog_watch::{catalog_watch, reconnect_watch, spawn_local}; pub(crate) use connection_tree::{ConnectionTree, SessionRowState}; -pub(crate) use favorites_pane::FavoritesPane; +pub(crate) use favorites_pane::{FavoriteAction, FavoritesPane}; pub(crate) use key_listing::{KeySidebar, KeysListed}; pub(super) use sidebar_affordances::SidebarAffordances; use sidebar_index::SidebarIndex; diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 3f35d692f1..9e38c4d9fd 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -250,6 +250,29 @@ mod tests { wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); } + /// A favorite is renamed and deleted from the list, which reads again. + #[gtk4::test] + fn a_favorite_is_renamed_and_deleted_from_the_list() { + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let test = TestWindow::connected("FavoritesChange"); + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("the query database to open"); + let shell = test.window.shell().expect("the shell"); + let favorites = shell.imp().favorites.get().cloned().expect("the favorites pane"); + shell.imp().scope_toggle.set_active_name(Some("favorites")); + test.workspace() + .with_model(|model| model.on_save_query_named("Orders".to_owned(), "SELECT 1".to_owned())); + wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); + let id = favorites.ids()[0]; + + shell.rename_favorite(id, "Weekly orders".to_owned()); + wait_until(WAIT, || favorites.names() == ["Weekly orders"]).expect("the new name to be listed"); + + shell.delete_favorite(id); + wait_until(WAIT, || favorites.names().is_empty()).expect("the favorite to go"); + } + #[gtk4::test] fn a_history_dialog_closed_by_hand_is_not_closed_again_on_disconnect() { use gtk4::glib; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 35188fda76..57d8053851 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -9,9 +9,11 @@ use gtk4::glib; use gtk4::prelude::*; use gtk4::subclass::prelude::*; use libadwaita as adw; -use libadwaita::prelude::BinExt; +use libadwaita::prelude::{AdwDialogExt, AlertDialogExt, BinExt, PreferencesGroupExt}; use tablepro_core::DataModel; use tablepro_session::SessionKey; +use tablepro_storage::SavedQueries; +use tablepro_storage::saved_queries::SavedQuery; use uuid::Uuid; use super::health_banner::REVIEW_HOST_KEY; @@ -96,7 +98,7 @@ impl WorkspaceShell { let favorites = super::sidebar::FavoritesPane::new(glib::clone!( #[weak] shell, - move |sql| shell.open_favorite(sql) + move |action| shell.on_favorite_action(action) )); sidebar.add_named(&favorites.widget(), Some(FAVORITES)); imp.sidebar_slot.set_child(Some(&sidebar)); @@ -599,13 +601,108 @@ impl WorkspaceShell { ); } - /// A favorite was picked: its SQL opens in a new query tab of the front session. - fn open_favorite(&self, sql: String) { - if let Some(sender) = self.front().and_then(|front| front.sender()) { - sender.deliver(super::WorkspaceInput::OpenHistoryQuery(sql)); + fn on_favorite_action(&self, action: super::sidebar::FavoriteAction) { + use super::sidebar::FavoriteAction; + match action { + // The SQL opens in a new query tab of the front session. + FavoriteAction::Open(sql) => { + if let Some(sender) = self.front().and_then(|front| front.sender()) { + sender.deliver(super::WorkspaceInput::OpenHistoryQuery(sql)); + } + } + FavoriteAction::Rename(favorite) => self.ask_favorite_name(favorite), + FavoriteAction::Delete(favorite) => self.ask_favorite_deletion(favorite), } } + fn ask_favorite_name(&self, favorite: SavedQuery) { + let dialog = adw::AlertDialog::new(Some(&gettext("Rename Favorite")), None); + let entry = adw::EntryRow::builder() + .title(gettext("Name")) + .activates_default(true) + .build(); + entry.set_text(&favorite.name); + let group = adw::PreferencesGroup::new(); + group.add(&entry); + dialog.set_extra_child(Some(&group)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("rename", &gettext("Rename")); + dialog.set_response_appearance("rename", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("rename")); + dialog.set_close_response("cancel"); + crate::ui::name_entry::require_name(&dialog, "rename", &entry); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let name = entry.text().trim().to_owned(); + if let (true, Some(shell)) = (response == "rename" && name != favorite.name, shell.upgrade()) { + shell.rename_favorite(favorite.id, name); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + fn ask_favorite_deletion(&self, favorite: SavedQuery) { + let dialog = adw::AlertDialog::new( + Some(&gettext_f("Delete “{name}”?", &[("name", &favorite.name)])), + Some(&gettext("The saved query is deleted. This cannot be undone.")), + ); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("delete", &gettext("Delete")); + dialog.set_response_appearance("delete", adw::ResponseAppearance::Destructive); + dialog.set_default_response(Some("cancel")); + dialog.set_close_response("cancel"); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + if let (true, Some(shell)) = (response == "delete", shell.upgrade()) { + shell.delete_favorite(favorite.id); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + pub(crate) fn rename_favorite(&self, id: i64, name: String) { + self.change_favorites( + async move |store| store.rename(id, &name).await, + gettext("Could not rename that saved query."), + ); + } + + pub(crate) fn delete_favorite(&self, id: i64) { + self.change_favorites( + async move |store| store.delete(id).await, + gettext("Could not delete that saved query."), + ); + } + + /// Run `change` on the saved queries, then read the list again, or + /// say `failure`. + fn change_favorites(&self, change: impl FnOnce(SavedQueries) -> W + Send + 'static, failure: String) + where + W: std::future::Future> + Send + 'static, + { + let Some((history, tasks)) = self.imp().favorites_source.get() else { + return; + }; + let ready = history.ready_store(); + let shell = self.downgrade(); + crate::runtime::spawn_and_deliver( + tasks, + async move { + let store = ready.await?.saved_queries(); + change(store).await.ok() + }, + move |done| { + let Some(shell) = shell.upgrade() else { + return; + }; + match done { + Ok(Some(())) => shell.reload_favorites(), + _ => shell.toast_overlay().add_toast(crate::ui::plain_toast(&failure)), + } + }, + ); + } + fn on_front_changed(&self) { let imp = self.imp(); if let Some(front) = self.front() { From b9a82bc7b7a30f4cfaeb6d40e4c0e83da454b162 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:02:18 +0100 Subject: [PATCH 05/23] refactor(linux-sidebar): let the window's tests ask the favorites' actions --- linux/crates/app/src/ui/workspace/workspace_shell.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 57d8053851..07737cd228 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -601,7 +601,7 @@ impl WorkspaceShell { ); } - fn on_favorite_action(&self, action: super::sidebar::FavoriteAction) { + pub(super) fn on_favorite_action(&self, action: super::sidebar::FavoriteAction) { use super::sidebar::FavoriteAction; match action { // The SQL opens in a new query tab of the front session. From ea788ec8fb01925170d7cd445304e10e84ec6ac8 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:02:25 +0100 Subject: [PATCH 06/23] docs(linux-sidebar): add the changelog entry --- linux/changelog.d/4115.added.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 linux/changelog.d/4115.added.md diff --git a/linux/changelog.d/4115.added.md b/linux/changelog.d/4115.added.md new file mode 100644 index 0000000000..01e35d6185 --- /dev/null +++ b/linux/changelog.d/4115.added.md @@ -0,0 +1 @@ +A favorite is renamed or deleted from the Favorites list, with a right click, F2 or Delete. From 26f7bcd7c6a9a83fc880a0c81829a6289acdf269 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:20:49 +0100 Subject: [PATCH 07/23] feat(core-storage): keep folders, keywords and favourite tables and databases beside saved queries --- .../migrations/20261108000000_favourites.sql | 46 +++ core/crates/storage/src/error.rs | 16 + core/crates/storage/src/favourites.rs | 194 ++++++++++++ core/crates/storage/src/lib.rs | 4 +- core/crates/storage/src/query_history/mod.rs | 63 +++- .../storage/src/saved_queries/folders.rs | 192 +++++++++++ core/crates/storage/src/saved_queries/mod.rs | 299 +++++++++++++++++- .../storage/src/saved_queries/saved_query.rs | 10 + core/docs/decisions/0017-favourites.md | 35 ++ core/docs/decisions/README.md | 1 + .../saved_query_listing.rs | 3 + .../app/src/ui/saved_queries_dialog/tests.rs | 3 + linux/docs/storage.md | 2 +- 13 files changed, 849 insertions(+), 19 deletions(-) create mode 100644 core/crates/storage/migrations/20261108000000_favourites.sql create mode 100644 core/crates/storage/src/favourites.rs create mode 100644 core/crates/storage/src/saved_queries/folders.rs create mode 100644 core/docs/decisions/0017-favourites.md diff --git a/core/crates/storage/migrations/20261108000000_favourites.sql b/core/crates/storage/migrations/20261108000000_favourites.sql new file mode 100644 index 0000000000..c9336027e0 --- /dev/null +++ b/core/crates/storage/migrations/20261108000000_favourites.sql @@ -0,0 +1,46 @@ +-- Folders and keywords on saved queries, and the tables and databases a +-- user marks as favourites (core ADR 0017). + +CREATE TABLE saved_query_folders ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + connection_id TEXT NOT NULL, + name TEXT NOT NULL, + -- A deleted folder takes the folders inside it. + parent_id INTEGER REFERENCES saved_query_folders (id) ON DELETE CASCADE, + sort_order INTEGER NOT NULL DEFAULT 0, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL +); + +-- No two siblings share a name in any case. A top-level folder has no +-- parent, which a unique index would treat as always different. +CREATE UNIQUE INDEX saved_query_folders_name_idx + ON saved_query_folders (connection_id, COALESCE(parent_id, 0), name COLLATE NOCASE); + +ALTER TABLE saved_queries ADD COLUMN keyword TEXT; +-- A deleted folder leaves its queries at the top. +ALTER TABLE saved_queries ADD COLUMN folder_id INTEGER REFERENCES saved_query_folders (id) ON DELETE SET NULL; +ALTER TABLE saved_queries ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0; + +CREATE UNIQUE INDEX saved_queries_keyword_idx + ON saved_queries (connection_id, keyword COLLATE NOCASE) WHERE keyword IS NOT NULL; + +-- A table is named by its database and schema where the engine has them, +-- and by the empty string where it does not, so the key is never NULL. +CREATE TABLE favourite_tables ( + connection_id TEXT NOT NULL, + database TEXT NOT NULL DEFAULT '', + schema TEXT NOT NULL DEFAULT '', + name TEXT NOT NULL, + created_at INTEGER NOT NULL, + PRIMARY KEY (connection_id, database, schema, name) +); + +CREATE TABLE favourite_databases ( + connection_id TEXT NOT NULL, + database TEXT NOT NULL, + environment TEXT NOT NULL DEFAULT 'unassigned' + CHECK (environment IN ('development', 'testing', 'production', 'unassigned')), + created_at INTEGER NOT NULL, + PRIMARY KEY (connection_id, database) +); diff --git a/core/crates/storage/src/error.rs b/core/crates/storage/src/error.rs index 1326c363c7..4fab9e196d 100644 --- a/core/crates/storage/src/error.rs +++ b/core/crates/storage/src/error.rs @@ -50,6 +50,18 @@ pub enum StorageError { #[error("another tag has that name")] TagNameTaken, + #[error("another saved query of the connection has that keyword")] + KeywordTaken, + + #[error("a keyword is one word of at most {max} characters, with no spaces")] + KeywordInvalid { max: usize }, + + #[error("another folder in the same place has that name")] + FolderNameTaken, + + #[error("the folder {id} cannot move inside itself")] + FolderCycle { id: i64 }, + #[error("export encoding failed: {0}")] Encode(#[from] tablepro_core::export::RenderError), @@ -104,6 +116,10 @@ impl StorageError { Self::EmptyName => "storage.empty_name", Self::NameTaken => "storage.name_taken", Self::TagNameTaken => "storage.tag_name_taken", + Self::KeywordTaken => "storage.keyword_taken", + Self::KeywordInvalid { .. } => "storage.keyword_invalid", + Self::FolderNameTaken => "storage.folder_name_taken", + Self::FolderCycle { .. } => "storage.folder_cycle", Self::Encode(..) => "storage.encode", Self::HistoryNewerThanApp { .. } => "storage.history_newer_than_app", Self::HistoryMigration(..) => "storage.history_migration", diff --git a/core/crates/storage/src/favourites.rs b/core/crates/storage/src/favourites.rs new file mode 100644 index 0000000000..2ad403851a --- /dev/null +++ b/core/crates/storage/src/favourites.rs @@ -0,0 +1,194 @@ +//! The tables and databases a user marks as favourites on a connection, +//! as the macOS sidebar keeps them (core ADR 0017). + +use std::time::SystemTime; + +use sqlx::{Row, SqlitePool}; +use uuid::Uuid; + +use crate::error::StorageError; +use crate::unix_time::to_unix; + +/// What a favourite database is for, the buckets the macOS list groups +/// them in. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DatabaseEnvironment { + Development, + Testing, + Production, + Unassigned, +} + +impl DatabaseEnvironment { + /// The word stored, which is also the macOS raw value. + pub fn as_str(self) -> &'static str { + match self { + Self::Development => "development", + Self::Testing => "testing", + Self::Production => "production", + Self::Unassigned => "unassigned", + } + } + + pub fn parse(text: &str) -> Option { + [Self::Development, Self::Testing, Self::Production, Self::Unassigned] + .into_iter() + .find(|environment| environment.as_str() == text) + } +} + +/// A table marked as a favourite, named as the catalogue names it: the +/// database and schema where the engine has them. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FavouriteTable { + pub connection_id: Uuid, + pub database: Option, + pub schema: Option, + pub name: String, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FavouriteDatabase { + pub connection_id: Uuid, + pub database: String, + pub environment: DatabaseEnvironment, +} + +/// The favourite tables and databases. Cloning shares the pool with the +/// history it lives beside. +#[derive(Debug, Clone)] +pub struct Favourites { + pool: SqlitePool, +} + +impl Favourites { + pub(crate) fn new(pool: SqlitePool) -> Self { + Self { pool } + } + + /// Mark a table. Marking one already marked changes nothing. + pub async fn add_table(&self, table: &FavouriteTable) -> Result<(), StorageError> { + if table.name.trim().is_empty() { + return Err(StorageError::EmptyName); + } + sqlx::query( + "INSERT OR IGNORE INTO favourite_tables (connection_id, database, schema, name, created_at) \ + VALUES (?, ?, ?, ?, ?)", + ) + .bind(table.connection_id.to_string()) + .bind(table.database.as_deref().unwrap_or_default()) + .bind(table.schema.as_deref().unwrap_or_default()) + .bind(&table.name) + .bind(to_unix(SystemTime::now())) + .execute(&self.pool) + .await?; + Ok(()) + } + + pub async fn remove_table(&self, table: &FavouriteTable) -> Result<(), StorageError> { + sqlx::query( + "DELETE FROM favourite_tables WHERE connection_id = ? AND database = ? AND schema = ? AND name = ?", + ) + .bind(table.connection_id.to_string()) + .bind(table.database.as_deref().unwrap_or_default()) + .bind(table.schema.as_deref().unwrap_or_default()) + .bind(&table.name) + .execute(&self.pool) + .await?; + Ok(()) + } + + /// The connection's favourite tables, by database, schema and name. + pub async fn tables(&self, connection: Uuid) -> Result, StorageError> { + let rows = sqlx::query( + "SELECT database, schema, name FROM favourite_tables WHERE connection_id = ? \ + ORDER BY database COLLATE NOCASE, schema COLLATE NOCASE, name COLLATE NOCASE", + ) + .bind(connection.to_string()) + .fetch_all(&self.pool) + .await?; + rows.into_iter() + .map(|row| { + let (database, schema): (String, String) = (row.try_get("database")?, row.try_get("schema")?); + Ok(FavouriteTable { + connection_id: connection, + database: Some(database).filter(|text| !text.is_empty()), + schema: Some(schema).filter(|text| !text.is_empty()), + name: row.try_get("name")?, + }) + }) + .collect() + } + + /// Mark a database, or change the environment of one marked. + pub async fn set_database( + &self, + connection: Uuid, + database: &str, + environment: DatabaseEnvironment, + ) -> Result<(), StorageError> { + if database.trim().is_empty() { + return Err(StorageError::EmptyName); + } + sqlx::query( + "INSERT INTO favourite_databases (connection_id, database, environment, created_at) \ + VALUES (?, ?, ?, ?) \ + ON CONFLICT (connection_id, database) DO UPDATE SET environment = excluded.environment", + ) + .bind(connection.to_string()) + .bind(database) + .bind(environment.as_str()) + .bind(to_unix(SystemTime::now())) + .execute(&self.pool) + .await?; + Ok(()) + } + + pub async fn remove_database(&self, connection: Uuid, database: &str) -> Result<(), StorageError> { + sqlx::query("DELETE FROM favourite_databases WHERE connection_id = ? AND database = ?") + .bind(connection.to_string()) + .bind(database) + .execute(&self.pool) + .await?; + Ok(()) + } + + /// The connection's favourite databases, by name. + pub async fn databases(&self, connection: Uuid) -> Result, StorageError> { + let rows = sqlx::query( + "SELECT database, environment FROM favourite_databases WHERE connection_id = ? \ + ORDER BY database COLLATE NOCASE", + ) + .bind(connection.to_string()) + .fetch_all(&self.pool) + .await?; + rows.into_iter() + .map(|row| { + let environment: String = row.try_get("environment")?; + Ok(FavouriteDatabase { + connection_id: connection, + database: row.try_get("database")?, + environment: DatabaseEnvironment::parse(&environment).unwrap_or(DatabaseEnvironment::Unassigned), + }) + }) + .collect() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn an_environment_round_trips_through_its_word() { + for environment in [ + DatabaseEnvironment::Development, + DatabaseEnvironment::Testing, + DatabaseEnvironment::Production, + DatabaseEnvironment::Unassigned, + ] { + assert_eq!(DatabaseEnvironment::parse(environment.as_str()), Some(environment)); + } + assert_eq!(DatabaseEnvironment::parse("staging"), None); + } +} diff --git a/core/crates/storage/src/lib.rs b/core/crates/storage/src/lib.rs index c0404bb9ac..d3543c442f 100644 --- a/core/crates/storage/src/lib.rs +++ b/core/crates/storage/src/lib.rs @@ -11,6 +11,7 @@ pub mod document; mod document_problem; pub mod drafts; mod error; +pub mod favourites; pub mod fs; mod group_icon; mod group_name_error; @@ -40,10 +41,11 @@ pub use credentials::{ pub use document_problem::{DocumentProblem, DocumentProblemKind}; pub use drafts::{DraftId, DraftScope, DraftStore}; pub use error::StorageError; +pub use favourites::{DatabaseEnvironment, FavouriteDatabase, FavouriteTable, Favourites}; pub use group_icon::{GroupIcon, SymbolName}; pub use group_name_error::GroupNameError; pub use group_tree::GroupTree; pub use paths::StoragePaths; pub use query_history::QueryHistory; -pub use saved_queries::SavedQueries; +pub use saved_queries::{SavedQueries, SavedQueryFolder, SavedQueryFolders}; pub use tag_name_error::TagNameError; diff --git a/core/crates/storage/src/query_history/mod.rs b/core/crates/storage/src/query_history/mod.rs index 04615093a9..c8129735db 100644 --- a/core/crates/storage/src/query_history/mod.rs +++ b/core/crates/storage/src/query_history/mod.rs @@ -101,6 +101,16 @@ impl QueryHistory { crate::saved_queries::SavedQueries::new(self.pool.clone(), self.path.clone()) } + /// The folders saved queries are filed in, in the same database. + pub fn saved_query_folders(&self) -> crate::saved_queries::SavedQueryFolders { + crate::saved_queries::SavedQueryFolders::new(self.pool.clone()) + } + + /// The favourite tables and databases, in the same database. + pub fn favourites(&self) -> crate::favourites::Favourites { + crate::favourites::Favourites::new(self.pool.clone()) + } + pub async fn record(&self, entry: NewEntry) -> Result { if entry.query.len() > MAX_QUERY_BYTES { return Err(StorageError::TooLarge { @@ -709,7 +719,56 @@ mod tests { .fetch_one(&history.pool) .await .expect("count migrations"); - assert_eq!(applied, 1); + assert_eq!(applied, 2); + } + + /// A database an earlier build wrote, with its saved queries, is kept + /// as a copy before the favourites' migration and then reads as it did, + /// with no keyword and no folder. + #[tokio::test] + async fn a_database_from_before_the_favourites_keeps_its_saved_queries() { + let root = tempfile::tempdir().expect("tempdir"); + let paths = paths(&root); + let path = paths.history_database(); + crate::fs::create_private_file_if_missing(&path).expect("the file"); + let pool = SqlitePoolOptions::new() + .max_connections(1) + .connect_with( + SqliteConnectOptions::new() + .filename(&path) + .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal), + ) + .await + .expect("a pool"); + sqlx::migrate::Migrator::with_migrations(schema::MIGRATOR.iter().take(1).cloned().collect()) + .run(&pool) + .await + .expect("the first migration"); + let connection = Uuid::new_v4(); + sqlx::query( + "INSERT INTO saved_queries (name, query, connection_id, connection_name, created_at, updated_at) \ + VALUES ('daily', 'SELECT 1', ?, 'local', 1, 1)", + ) + .bind(connection.to_string()) + .execute(&pool) + .await + .expect("a saved query"); + pool.close().await; + + let history = QueryHistory::open(&paths).await.expect("open"); + + let saved = history.saved_queries().list(Some(connection)).await.expect("list"); + assert_eq!(saved.len(), 1); + assert_eq!( + (saved[0].keyword.as_deref(), saved[0].folder_id, saved[0].order), + (None, None, 0) + ); + assert!( + !crate::upgrade_copies::copies_blocking(&path) + .expect("copies") + .is_empty(), + "no copy was kept before the migration" + ); } #[tokio::test] @@ -854,7 +913,7 @@ mod tests { /// means a change went into a file that has already run somewhere. #[test] fn migrator_embeds_every_migration() { - assert_eq!(schema::MIGRATOR.iter().count(), 1); + assert_eq!(schema::MIGRATOR.iter().count(), 2); } #[tokio::test] diff --git a/core/crates/storage/src/saved_queries/folders.rs b/core/crates/storage/src/saved_queries/folders.rs new file mode 100644 index 0000000000..2884cb7ecc --- /dev/null +++ b/core/crates/storage/src/saved_queries/folders.rs @@ -0,0 +1,192 @@ +use std::time::SystemTime; + +use sqlx::{Row, SqlitePool}; +use uuid::Uuid; + +use crate::error::StorageError; +use crate::unix_time::{from_unix, to_unix}; + +/// A folder of a connection's saved queries, which can hold others. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SavedQueryFolder { + pub id: i64, + pub connection_id: Uuid, + pub name: String, + /// The folder it sits in, none at the top of the connection's list. + pub parent_id: Option, + /// Its place among the folders of its parent. + pub order: i64, + pub created_at: SystemTime, + pub updated_at: SystemTime, +} + +/// A name long enough to be unreadable in the list is a name nobody +/// meant to type, as for a saved query. +const MAX_NAME_CHARS: usize = 200; + +/// The folders saved queries are filed in. Cloning shares the pool with +/// the history it lives beside. +#[derive(Debug, Clone)] +pub struct SavedQueryFolders { + pool: SqlitePool, +} + +impl SavedQueryFolders { + pub(crate) fn new(pool: SqlitePool) -> Self { + Self { pool } + } + + /// Make a folder in `parent`, none for the top, last among its + /// siblings. The parent must be the same connection's. + pub async fn create(&self, connection: Uuid, name: &str, parent: Option) -> Result { + let name = checked_name(name)?; + if let Some(parent) = parent { + let owner: Option = + sqlx::query_scalar("SELECT connection_id FROM saved_query_folders WHERE id = ?") + .bind(parent) + .fetch_optional(&self.pool) + .await?; + if owner.as_deref() != Some(connection.to_string().as_str()) { + return Err(StorageError::NotFound); + } + } + let now = to_unix(SystemTime::now()); + let id = sqlx::query( + "INSERT INTO saved_query_folders (connection_id, name, parent_id, sort_order, created_at, updated_at) \ + VALUES (?1, ?2, ?3, \ + (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_query_folders \ + WHERE connection_id = ?1 AND parent_id IS ?3), ?4, ?4) \ + RETURNING id", + ) + .bind(connection.to_string()) + .bind(name) + .bind(parent) + .bind(now) + .fetch_one(&self.pool) + .await + .map_err(name_taken)? + .try_get("id")?; + Ok(id) + } + + pub async fn rename(&self, id: i64, name: &str) -> Result<(), StorageError> { + let name = checked_name(name)?; + let affected = sqlx::query("UPDATE saved_query_folders SET name = ?, updated_at = ? WHERE id = ?") + .bind(name) + .bind(to_unix(SystemTime::now())) + .bind(id) + .execute(&self.pool) + .await + .map_err(name_taken)? + .rows_affected(); + match affected { + 0 => Err(StorageError::NotFound), + _ => Ok(()), + } + } + + /// Move a folder into `parent`, none for the top, last among the + /// folders there. A folder never goes inside itself or inside one it + /// holds. + pub async fn move_to(&self, id: i64, parent: Option) -> Result<(), StorageError> { + let mut transaction = self.pool.begin().await?; + let connection: Option = + sqlx::query_scalar("SELECT connection_id FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await?; + let connection = connection.ok_or(StorageError::NotFound)?; + let mut above = parent; + while let Some(held) = above { + if held == id { + return Err(StorageError::FolderCycle { id }); + } + let row = sqlx::query("SELECT connection_id, parent_id FROM saved_query_folders WHERE id = ?") + .bind(held) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + if row.try_get::("connection_id")? != connection { + return Err(StorageError::NotFound); + } + above = row.try_get("parent_id")?; + } + sqlx::query( + "UPDATE saved_query_folders SET parent_id = ?1, updated_at = ?2, \ + sort_order = (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_query_folders \ + WHERE connection_id = ?3 AND parent_id IS ?1) \ + WHERE id = ?4", + ) + .bind(parent) + .bind(to_unix(SystemTime::now())) + .bind(connection) + .bind(id) + .execute(&mut *transaction) + .await + .map_err(name_taken)?; + transaction.commit().await?; + Ok(()) + } + + /// Delete a folder and the folders in it. The queries filed in them + /// stay, at the top of the connection's list. + pub async fn delete(&self, id: i64) -> Result<(), StorageError> { + let affected = sqlx::query("DELETE FROM saved_query_folders WHERE id = ?") + .bind(id) + .execute(&self.pool) + .await? + .rows_affected(); + match affected { + 0 => Err(StorageError::NotFound), + _ => Ok(()), + } + } + + /// Every folder of `connection`, the order a list shows them in: by + /// parent, then place, then name. + pub async fn list(&self, connection: Uuid) -> Result, StorageError> { + let rows = sqlx::query( + "SELECT id, connection_id, name, parent_id, sort_order, created_at, updated_at \ + FROM saved_query_folders WHERE connection_id = ? \ + ORDER BY COALESCE(parent_id, 0), sort_order, name COLLATE NOCASE, id", + ) + .bind(connection.to_string()) + .fetch_all(&self.pool) + .await?; + rows.into_iter() + .map(|row| { + let owner: String = row.try_get("connection_id")?; + Ok(SavedQueryFolder { + id: row.try_get("id")?, + connection_id: Uuid::parse_str(&owner).unwrap_or_default(), + name: row.try_get("name")?, + parent_id: row.try_get("parent_id")?, + order: row.try_get("sort_order")?, + created_at: from_unix(row.try_get::("created_at")?), + updated_at: from_unix(row.try_get::("updated_at")?), + }) + }) + .collect() + } +} + +fn checked_name(name: &str) -> Result<&str, StorageError> { + let name = name.trim(); + if name.is_empty() { + return Err(StorageError::EmptyName); + } + if name.chars().count() > MAX_NAME_CHARS { + return Err(StorageError::TooLarge { + got: name.chars().count(), + limit: MAX_NAME_CHARS, + }); + } + Ok(name) +} + +fn name_taken(error: sqlx::Error) -> StorageError { + match &error { + sqlx::Error::Database(database) if database.is_unique_violation() => StorageError::FolderNameTaken, + _ => StorageError::Database(error), + } +} diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index 4a4a00737c..ddd298a4c3 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -1,3 +1,4 @@ +mod folders; mod new_saved_query; mod saved_query; @@ -9,9 +10,21 @@ use uuid::Uuid; use crate::error::StorageError; use crate::unix_time::{from_unix, to_unix}; +pub use folders::{SavedQueryFolder, SavedQueryFolders}; pub use new_saved_query::NewSavedQuery; pub use saved_query::SavedQuery; +/// The columns a saved query is read from, in one place so a read and its +/// row mapping cannot drift. +macro_rules! columns { + () => { + "id, name, query, connection_id, connection_name, keyword, folder_id, sort_order, created_at, updated_at" + }; +} + +/// The longest keyword, which is typed to expand. +const MAX_KEYWORD_CHARS: usize = 64; + /// What a save did, so the caller can say which. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SaveOutcome { @@ -149,19 +162,21 @@ impl SavedQueries { pub async fn list(&self, connection: Option) -> Result, StorageError> { let rows = match connection { Some(id) => { - sqlx::query( - "SELECT id, name, query, connection_id, connection_name, created_at, updated_at \ - FROM saved_queries WHERE connection_id = ? ORDER BY name COLLATE NOCASE, id", - ) + sqlx::query(concat!( + "SELECT ", + columns!(), + " FROM saved_queries WHERE connection_id = ? ORDER BY name COLLATE NOCASE, id" + )) .bind(id.to_string()) .fetch_all(&self.pool) .await? } None => { - sqlx::query( - "SELECT id, name, query, connection_id, connection_name, created_at, updated_at \ - FROM saved_queries ORDER BY connection_name COLLATE NOCASE, name COLLATE NOCASE, id", - ) + sqlx::query(concat!( + "SELECT ", + columns!(), + " FROM saved_queries ORDER BY connection_name COLLATE NOCASE, name COLLATE NOCASE, id" + )) .fetch_all(&self.pool) .await? } @@ -170,13 +185,10 @@ impl SavedQueries { } pub async fn get(&self, id: i64) -> Result, StorageError> { - let row = sqlx::query( - "SELECT id, name, query, connection_id, connection_name, created_at, updated_at \ - FROM saved_queries WHERE id = ?", - ) - .bind(id) - .fetch_optional(&self.pool) - .await?; + let row = sqlx::query(concat!("SELECT ", columns!(), " FROM saved_queries WHERE id = ?")) + .bind(id) + .fetch_optional(&self.pool) + .await?; row.map(row_to_saved_query).transpose() } @@ -211,6 +223,82 @@ impl SavedQueries { } } + /// Give a saved query the word that expands to it in the editor, or + /// none. A word is one run of characters with no whitespace, kept as + /// typed; two queries of a connection never share one in any case. + pub async fn set_keyword(&self, id: i64, keyword: Option<&str>) -> Result<(), StorageError> { + let keyword = keyword.map(str::trim).filter(|word| !word.is_empty()); + if let Some(word) = keyword + && (word.chars().count() > MAX_KEYWORD_CHARS || word.chars().any(|c| c.is_whitespace() || c.is_control())) + { + return Err(StorageError::KeywordInvalid { max: MAX_KEYWORD_CHARS }); + } + let affected = sqlx::query("UPDATE saved_queries SET keyword = ?, updated_at = ? WHERE id = ?") + .bind(keyword) + .bind(to_unix(SystemTime::now())) + .bind(id) + .execute(&self.pool) + .await + .map_err(|error| match &error { + sqlx::Error::Database(database) if database.is_unique_violation() => StorageError::KeywordTaken, + _ => StorageError::Database(error), + })? + .rows_affected(); + match affected { + 0 => Err(StorageError::NotFound), + _ => Ok(()), + } + } + + /// File a saved query in `folder`, none for the top, before another + /// query of that place or last. The folder must be the same + /// connection's. The places of the queries there are numbered from 0 + /// again, so the order is whole. + pub async fn move_to_folder(&self, id: i64, folder: Option, before: Option) -> Result<(), StorageError> { + let mut transaction = self.pool.begin().await?; + let connection: Option = sqlx::query_scalar("SELECT connection_id FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await?; + let connection = connection.ok_or(StorageError::NotFound)?; + if let Some(folder) = folder { + let owner: Option = + sqlx::query_scalar("SELECT connection_id FROM saved_query_folders WHERE id = ?") + .bind(folder) + .fetch_optional(&mut *transaction) + .await?; + if owner.as_deref() != Some(connection.as_str()) { + return Err(StorageError::NotFound); + } + } + let mut place: Vec = sqlx::query_scalar( + "SELECT id FROM saved_queries WHERE folder_id IS ? AND id <> ? ORDER BY sort_order, name COLLATE NOCASE, id", + ) + .bind(folder) + .bind(id) + .fetch_all(&mut *transaction) + .await?; + let at = before + .and_then(|before| place.iter().position(|held| *held == before)) + .unwrap_or(place.len()); + place.insert(at, id); + sqlx::query("UPDATE saved_queries SET folder_id = ?, updated_at = ? WHERE id = ?") + .bind(folder) + .bind(to_unix(SystemTime::now())) + .bind(id) + .execute(&mut *transaction) + .await?; + for (order, held) in place.iter().enumerate() { + sqlx::query("UPDATE saved_queries SET sort_order = ? WHERE id = ?") + .bind(i64::try_from(order).unwrap_or(i64::MAX)) + .bind(held) + .execute(&mut *transaction) + .await?; + } + transaction.commit().await?; + Ok(()) + } + pub async fn delete(&self, id: i64) -> Result<(), StorageError> { crate::query_history::trim_upgrade_copies( &self.path, @@ -250,6 +338,18 @@ impl SavedQueries { .execute(&self.pool) .await? .rows_affected(); + // What a connection's queries are filed under and the tables and + // databases marked beside them name only that connection's schema. + for statement in [ + "DELETE FROM saved_query_folders WHERE connection_id = ?", + "DELETE FROM favourite_tables WHERE connection_id = ?", + "DELETE FROM favourite_databases WHERE connection_id = ?", + ] { + sqlx::query(statement) + .bind(connection.to_string()) + .execute(&self.pool) + .await?; + } Ok(affected as usize) } } @@ -262,6 +362,9 @@ fn row_to_saved_query(row: sqlx::sqlite::SqliteRow) -> Result("created_at")?), updated_at: from_unix(row.try_get::("updated_at")?), }) @@ -306,6 +409,172 @@ mod tests { assert_eq!(saved.connection_name, "local"); } + #[tokio::test] + async fn a_keyword_is_one_word_unique_to_the_connection_in_any_case() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + let first = store + .save(new_query("a", "SELECT 1", connection)) + .await + .expect("save") + .id; + let second = store + .save(new_query("b", "SELECT 2", connection)) + .await + .expect("save") + .id; + let elsewhere = store + .save(new_query("c", "SELECT 3", Uuid::new_v4())) + .await + .expect("save") + .id; + + store.set_keyword(first, Some(" Daily ")).await.expect("a keyword"); + assert_eq!( + store + .get(first) + .await + .expect("get") + .expect("the query") + .keyword + .as_deref(), + Some("Daily") + ); + assert!(matches!( + store.set_keyword(second, Some("daily")).await, + Err(StorageError::KeywordTaken) + )); + assert!(matches!( + store.set_keyword(second, Some("two words")).await, + Err(StorageError::KeywordInvalid { .. }) + )); + store + .set_keyword(elsewhere, Some("daily")) + .await + .expect("another connection may reuse it"); + + store + .set_keyword(first, Some(" ")) + .await + .expect("a blank keyword clears"); + assert_eq!(store.get(first).await.expect("get").expect("the query").keyword, None); + store + .set_keyword(second, Some("daily")) + .await + .expect("the keyword is free again"); + } + + #[tokio::test] + async fn queries_are_filed_in_folders_that_nest_and_go_with_their_parent() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro")) + .await + .expect("open"); + let (store, folders) = (history.saved_queries(), history.saved_query_folders()); + let connection = Uuid::new_v4(); + let reports = folders.create(connection, "Reports", None).await.expect("a folder"); + let monthly = folders + .create(connection, "Monthly", Some(reports)) + .await + .expect("a subfolder"); + let a = store + .save(new_query("a", "SELECT 1", connection)) + .await + .expect("save") + .id; + let b = store + .save(new_query("b", "SELECT 2", connection)) + .await + .expect("save") + .id; + + store.move_to_folder(a, Some(monthly), None).await.expect("file a"); + store + .move_to_folder(b, Some(monthly), Some(a)) + .await + .expect("file b before a"); + async fn placed(store: &SavedQueries, id: i64) -> (Option, i64) { + let query = store.get(id).await.expect("get").expect("the query"); + (query.folder_id, query.order) + } + assert_eq!(placed(&store, b).await, (Some(monthly), 0)); + assert_eq!(placed(&store, a).await, (Some(monthly), 1)); + + assert!(matches!( + folders.create(connection, "REPORTS", None).await, + Err(StorageError::FolderNameTaken) + )); + assert!(matches!( + folders.move_to(reports, Some(monthly)).await, + Err(StorageError::FolderCycle { .. }) + )); + let other = folders + .create(Uuid::new_v4(), "Elsewhere", None) + .await + .expect("another connection's"); + assert!(matches!( + store.move_to_folder(a, Some(other), None).await, + Err(StorageError::NotFound) + )); + + folders.delete(reports).await.expect("delete the folder"); + assert!( + folders.list(connection).await.expect("list").is_empty(), + "a subfolder outlived its parent" + ); + assert_eq!(placed(&store, a).await.0, None, "a query went with its folder"); + } + + #[tokio::test] + async fn favourite_tables_and_databases_are_kept_per_connection_and_go_with_it() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro")) + .await + .expect("open"); + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let orders = crate::favourites::FavouriteTable { + connection_id: connection, + database: None, + schema: Some("public".to_owned()), + name: "orders".to_owned(), + }; + + favourites.add_table(&orders).await.expect("mark a table"); + favourites + .add_table(&orders) + .await + .expect("marking it again changes nothing"); + favourites + .set_database(connection, "shop", crate::favourites::DatabaseEnvironment::Testing) + .await + .expect("mark a database"); + favourites + .set_database(connection, "shop", crate::favourites::DatabaseEnvironment::Production) + .await + .expect("change its environment"); + + assert_eq!( + favourites.tables(connection).await.expect("tables"), + std::slice::from_ref(&orders) + ); + let databases = favourites.databases(connection).await.expect("databases"); + assert_eq!(databases.len(), 1); + assert_eq!( + databases[0].environment, + crate::favourites::DatabaseEnvironment::Production + ); + + store(&root) + .await + .delete_for_connection(connection) + .await + .expect("remove the connection's data"); + assert!(favourites.tables(connection).await.expect("tables").is_empty()); + assert!(favourites.databases(connection).await.expect("databases").is_empty()); + } + #[tokio::test] async fn saving_if_new_leaves_a_held_name_alone() { let root = tempfile::tempdir().expect("tempdir"); diff --git a/core/crates/storage/src/saved_queries/saved_query.rs b/core/crates/storage/src/saved_queries/saved_query.rs index 643175d098..5cd70169d8 100644 --- a/core/crates/storage/src/saved_queries/saved_query.rs +++ b/core/crates/storage/src/saved_queries/saved_query.rs @@ -15,6 +15,13 @@ pub struct SavedQuery { /// The connection's name as of the last save, which is what the /// list shows when the connection itself is gone. pub connection_name: String, + /// What the user types in the editor to get the query, one word, + /// unique among the connection's queries in any case. + pub keyword: Option, + /// The folder it is filed in, none for the top of the connection's list. + pub folder_id: Option, + /// Its place among the queries of its folder. + pub order: i64, pub created_at: SystemTime, pub updated_at: SystemTime, } @@ -41,6 +48,9 @@ mod tests { query: query.to_owned(), connection_id: Uuid::nil(), connection_name: "local".to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: SystemTime::UNIX_EPOCH, updated_at: SystemTime::UNIX_EPOCH, } diff --git a/core/docs/decisions/0017-favourites.md b/core/docs/decisions/0017-favourites.md new file mode 100644 index 0000000000..84a2639c03 --- /dev/null +++ b/core/docs/decisions/0017-favourites.md @@ -0,0 +1,35 @@ +# 0017: Favourites keep folders and keywords on saved queries, and the tables and databases a user marks + +- **Status**: Accepted +- **Date**: 2026-11-08 + +## Context + +The macOS sidebar has a Favorites scope next to Tables. It lists SQL favorites in folders, each with a name, a query and an optional keyword that expands in the editor, and the tables and databases the user marked, with each database filed under an environment (`SQLFavorite`, `SQLFavoriteFolder`, `FavoriteTablesStorage.FavoriteEntry`, `FavoriteDatabaseEntry`). The core keeps one half of this: `tablepro-storage` has saved queries, a name and a query per connection, in the query history's SQLite database. The Linux sidebar lists them, flat (linux PRs on the Favorites scope). Windows and the macOS app's move to the core ([0010](0010-macos-on-the-core.md)) need the rest, so it belongs in the core and not in one app. + +## Decision + +The folders, the keywords, the order and the marked tables and databases live in the history's database, added by one migration, `20261108000000_favourites.sql`, and reached through `QueryHistory::saved_queries`, `saved_query_folders` and `favourites`. + +## Rationale + +- **The same database.** Saved queries already live there, so a folder or a keyword is a column or a table beside them, in one transaction and one migration chain, and `delete_for_connection` removes all of a connection's favourites in one call. +- **Integer ids, not UUIDs.** A folder is a row of `saved_query_folders` with an `INTEGER` key, as a saved query has. macOS's UUID ids are not kept; a later importer maps them by name and place, as [0006](0006-connection-library.md) does for groups. +- **A folder is per connection**, with a parent id. Siblings never share a name in any case. Deleting a folder deletes the folders in it and leaves their queries at the top, as deleting a group does ([0006](0006-connection-library.md)). A folder never moves inside itself. +- **A keyword is one word**, at most 64 characters with no whitespace, unique among a connection's queries in any case, as macOS's unique index on keyword and connection. Folders nest without a depth limit, as on macOS. +- **Order is a number per place**, numbered from 0 again on each move, so a place always holds each position once. +- **A favourite table is keyed by connection, database, schema and name**, the empty string standing for none so the key is never `NULL`. A favourite database carries one of four environments, the four macOS buckets, in a column with a check. +- **Errors are `StorageError` variants with stable codes**: `storage.keyword_taken`, `keyword_invalid`, `folder_name_taken` and `folder_cycle`, with `not_found` and `empty_name` as before. + +## Consequences + +- A database an earlier build wrote is copied beside itself before the migration ([0012](0012-copies-before-a-format-upgrade.md)); a build before this one refuses it, as it refuses any newer one. The copies hold none of the new tables, since they are made from the older format, so deleting a folder or a favourite needs no trim of them. +- `SavedQuery` gains `keyword`, `folder_id` and `order`. `NewSavedQuery` is unchanged: a save keeps the keyword and the place of the query it replaces. +- Not here: the macOS team library, linked folders and per-file favourites, which stay outside the core, and the FFI surface, which a later change adds when Windows or macOS shows favourites. +- The Linux sidebar shows the folders, the keyword expansion and the marked tables and databases in later changes, each its own pull request. + +## Alternatives considered + +- **A JSON document, as the connection library.** Saved queries are in SQLite already, so folders in a file would split one list across two stores and two writers. +- **UUID ids to match macOS.** A second key beside the row id, and an id nothing here joins on. +- **A keyword unique across connections.** macOS scopes it to the connection, since a saved query is written for one database's schema. diff --git a/core/docs/decisions/README.md b/core/docs/decisions/README.md index 202c9f2576..cc8675ce3a 100644 --- a/core/docs/decisions/README.md +++ b/core/docs/decisions/README.md @@ -24,3 +24,4 @@ The format, the statuses and how a later ADR changes an earlier one follow [the | [0014](0014-tls-mode-of-a-new-connection.md) | A new connection starts on the TLS mode the engine's own client starts on | Accepted | `TlsMode::Prefer` for PostgreSQL and MySQL, Verify full for SQL Server, Disable for the engines that decide TLS by the port, with a DNS seed list and ClickHouse's HTTPS ports on Verify full; the core holds the rule, and every TLS failure a mode change fixes offers Change Encryption. | | [0015](0015-editing-a-query-result.md) | A query result edits when its statement reads one table and its driver traces the columns | Accepted | The parser accepts one row-preserving SELECT over one table; each driver sets `ResultColumn::origin` only for a direct column of a permanent base table, from the wire or a lookup on its own connection; the result maps to the catalog with its full primary key and saves through `plan_save`. | | [0016](0016-tablepro-accounts.md) | TablePro accounts live in the core, with features gated by the entitlement | Accepted | `tablepro-account` signs in through the browser with OAuth and a loopback redirect, registers the device, verifies the Ed25519 entitlement and gates features by its codes; each app passes its keyring, browser, machine ID and OAuth client in. | +| [0017](0017-favourites.md) | Favourites keep folders and keywords on saved queries, and the tables and databases a user marks | Accepted | One migration in the history's database adds per-connection folders that nest, a keyword and an order on saved queries, and favourite tables and databases with the four macOS environments; stable error codes, no UUID ids, and a database an older build wrote is copied first. | diff --git a/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs b/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs index 05d48a4de6..806b6de367 100644 --- a/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs +++ b/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs @@ -83,6 +83,9 @@ mod tests { query: query.to_owned(), connection_id, connection_name: connection.to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: SystemTime::UNIX_EPOCH, updated_at: SystemTime::UNIX_EPOCH, } diff --git a/linux/crates/app/src/ui/saved_queries_dialog/tests.rs b/linux/crates/app/src/ui/saved_queries_dialog/tests.rs index 74c27ce3d7..abc858a73f 100644 --- a/linux/crates/app/src/ui/saved_queries_dialog/tests.rs +++ b/linux/crates/app/src/ui/saved_queries_dialog/tests.rs @@ -301,6 +301,9 @@ fn a_row_shows_its_name_and_summary_as_written() { query: "\n SELECT 1 & 2\nFROM t".to_owned(), connection_id: Uuid::nil(), connection_name: "local".to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: SystemTime::UNIX_EPOCH, updated_at: SystemTime::UNIX_EPOCH, }; diff --git a/linux/docs/storage.md b/linux/docs/storage.md index d21106bf82..3c36a0dea6 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -10,7 +10,7 @@ The app's data goes to the store its shape calls for. The core's `storage` crate | The account's device ID and last entitlement, or an imported offline file | JSON file | `tablepro-account` ([core ADR 0016](../../core/docs/decisions/0016-tablepro-accounts.md), [ADR 0038](decisions/0038-account-page-and-license-ask.md)) | | The usage data's anonymous ID and what it sent once | JSON file | `Telemetry` in the app crate ([ADR 0039](decisions/0039-usage-data.md)) | | Preferences and window geometry | `gio::Settings` | `AppSettings` | -| Query history and saved queries | SQLite, one database | `QueryHistory`, `SavedQueries` | +| Query history, saved queries with their folders and keywords, and favourite tables and databases | SQLite, one database ([core ADR 0017](../../core/docs/decisions/0017-favourites.md)) | `QueryHistory`, `SavedQueries`, `SavedQueryFolders`, `Favourites` | | Editor tab text | one file per tab | `DraftStore` | | Open tabs, open sessions, column layouts, filters | JSON files the app crate writes | `WorkspaceStore`, `OpenSessions`, `crates/app/src/persistence/` | From 7834b7a4bc7e439eef526c76bfd28ed71480f1bd Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:25:29 +0100 Subject: [PATCH 08/23] fix(core-storage): remove a deleted folder or favourite from the upgrade copies too --- core/crates/storage/src/favourites.rs | 35 +++++++++- core/crates/storage/src/query_history/mod.rs | 65 ++++++++++++++++++- .../storage/src/saved_queries/folders.rs | 18 ++++- core/crates/storage/src/saved_queries/mod.rs | 35 +++++++--- core/docs/decisions/0017-favourites.md | 2 +- 5 files changed, 138 insertions(+), 17 deletions(-) diff --git a/core/crates/storage/src/favourites.rs b/core/crates/storage/src/favourites.rs index 2ad403851a..5fb67a390c 100644 --- a/core/crates/storage/src/favourites.rs +++ b/core/crates/storage/src/favourites.rs @@ -1,6 +1,7 @@ //! The tables and databases a user marks as favourites on a connection, //! as the macOS sidebar keeps them (core ADR 0017). +use std::path::PathBuf; use std::time::SystemTime; use sqlx::{Row, SqlitePool}; @@ -59,11 +60,13 @@ pub struct FavouriteDatabase { #[derive(Debug, Clone)] pub struct Favourites { pool: SqlitePool, + // The database's file, whose upgrade copies a removal reaches too. + path: PathBuf, } impl Favourites { - pub(crate) fn new(pool: SqlitePool) -> Self { - Self { pool } + pub(crate) fn new(pool: SqlitePool, path: PathBuf) -> Self { + Self { pool, path } } /// Mark a table. Marking one already marked changes nothing. @@ -86,6 +89,22 @@ impl Favourites { } pub async fn remove_table(&self, table: &FavouriteTable) -> Result<(), StorageError> { + crate::query_history::trim_upgrade_copies( + &self.path, + &[crate::query_history::CopyDelete { + table: "favourite_tables", + sql: "DELETE FROM main.favourite_tables \ + WHERE connection_id = ? AND database = ? AND schema = ? AND name = ?" + .to_owned(), + binds: vec![ + crate::query_history::Bind::Text(table.connection_id.to_string()), + crate::query_history::Bind::Text(table.database.clone().unwrap_or_default()), + crate::query_history::Bind::Text(table.schema.clone().unwrap_or_default()), + crate::query_history::Bind::Text(table.name.clone()), + ], + }], + ) + .await?; sqlx::query( "DELETE FROM favourite_tables WHERE connection_id = ? AND database = ? AND schema = ? AND name = ?", ) @@ -145,6 +164,18 @@ impl Favourites { } pub async fn remove_database(&self, connection: Uuid, database: &str) -> Result<(), StorageError> { + crate::query_history::trim_upgrade_copies( + &self.path, + &[crate::query_history::CopyDelete { + table: "favourite_databases", + sql: "DELETE FROM main.favourite_databases WHERE connection_id = ? AND database = ?".to_owned(), + binds: vec![ + crate::query_history::Bind::Text(connection.to_string()), + crate::query_history::Bind::Text(database.to_owned()), + ], + }], + ) + .await?; sqlx::query("DELETE FROM favourite_databases WHERE connection_id = ? AND database = ?") .bind(connection.to_string()) .bind(database) diff --git a/core/crates/storage/src/query_history/mod.rs b/core/crates/storage/src/query_history/mod.rs index c8129735db..3d9a70309d 100644 --- a/core/crates/storage/src/query_history/mod.rs +++ b/core/crates/storage/src/query_history/mod.rs @@ -103,12 +103,12 @@ impl QueryHistory { /// The folders saved queries are filed in, in the same database. pub fn saved_query_folders(&self) -> crate::saved_queries::SavedQueryFolders { - crate::saved_queries::SavedQueryFolders::new(self.pool.clone()) + crate::saved_queries::SavedQueryFolders::new(self.pool.clone(), self.path.clone()) } /// The favourite tables and databases, in the same database. pub fn favourites(&self) -> crate::favourites::Favourites { - crate::favourites::Favourites::new(self.pool.clone()) + crate::favourites::Favourites::new(self.pool.clone(), self.path.clone()) } pub async fn record(&self, entry: NewEntry) -> Result { @@ -548,7 +548,7 @@ async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), statement.execute(&mut *transaction).await?; } } - for table in ["history", "saved_queries"] { + for table in ["history", "saved_queries", "saved_query_folders"] { let present: i64 = sqlx::query_scalar( "SELECT (SELECT COUNT(*) FROM main.sqlite_master WHERE type = 'table' AND name = ?1) \ * (SELECT COUNT(*) FROM live.sqlite_master WHERE type = 'table' AND name = ?1)", @@ -1460,6 +1460,65 @@ mod tests { assert!(indexed(©, "qqq").await); } + /// A copy made after the favourites existed holds no folder, table or + /// database the user then deleted. + #[tokio::test] + async fn deleted_folders_and_favourites_leave_the_copies_too() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let connection = Uuid::new_v4(); + let folders = history.saved_query_folders(); + let favourites = history.favourites(); + let folder = folders.create(connection, "Reports", None).await.expect("a folder"); + folders + .create(connection, "Monthly", Some(folder)) + .await + .expect("a subfolder"); + let table = crate::favourites::FavouriteTable { + connection_id: connection, + database: None, + schema: None, + name: "orders".to_owned(), + }; + favourites.add_table(&table).await.expect("a table"); + favourites + .set_database(connection, "shop", crate::favourites::DatabaseEnvironment::Testing) + .await + .expect("a database"); + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("a copy"); + async fn kept(copy: &Path) -> Vec { + let mut database = SqliteConnectOptions::new() + .filename(copy) + .read_only(true) + .connect() + .await + .expect("open the copy"); + let mut counts = Vec::new(); + for table in ["saved_query_folders", "favourite_tables", "favourite_databases"] { + counts.push( + sqlx::query_scalar(AssertSqlSafe(format!("SELECT COUNT(*) FROM {table}"))) + .fetch_one(&mut database) + .await + .expect("count"), + ); + } + database.close().await.expect("close"); + counts + } + assert_eq!(kept(©).await, [2, 1, 1]); + + folders.delete(folder).await.expect("delete the folder"); + favourites.remove_table(&table).await.expect("remove the table"); + favourites + .remove_database(connection, "shop") + .await + .expect("remove the database"); + + assert_eq!(kept(©).await, [0, 0, 0], "a deleted favourite stayed in the copy"); + } + #[tokio::test] async fn a_copy_that_cannot_be_trimmed_is_removed() { let root = tempfile::tempdir().expect("tempdir"); diff --git a/core/crates/storage/src/saved_queries/folders.rs b/core/crates/storage/src/saved_queries/folders.rs index 2884cb7ecc..aac5e55f6e 100644 --- a/core/crates/storage/src/saved_queries/folders.rs +++ b/core/crates/storage/src/saved_queries/folders.rs @@ -1,3 +1,4 @@ +use std::path::PathBuf; use std::time::SystemTime; use sqlx::{Row, SqlitePool}; @@ -29,11 +30,13 @@ const MAX_NAME_CHARS: usize = 200; #[derive(Debug, Clone)] pub struct SavedQueryFolders { pool: SqlitePool, + // The database's file, whose upgrade copies a delete reaches too. + path: PathBuf, } impl SavedQueryFolders { - pub(crate) fn new(pool: SqlitePool) -> Self { - Self { pool } + pub(crate) fn new(pool: SqlitePool, path: PathBuf) -> Self { + Self { pool, path } } /// Make a folder in `parent`, none for the top, last among its @@ -131,6 +134,17 @@ impl SavedQueryFolders { /// Delete a folder and the folders in it. The queries filed in them /// stay, at the top of the connection's list. pub async fn delete(&self, id: i64) -> Result<(), StorageError> { + // The folders in it go from the copies with it, by the cascade, and + // the copies' sweep of folders the database no longer has. + crate::query_history::trim_upgrade_copies( + &self.path, + &[crate::query_history::CopyDelete { + table: "saved_query_folders", + sql: "DELETE FROM main.saved_query_folders WHERE id = ?".to_owned(), + binds: vec![crate::query_history::Bind::Integer(id)], + }], + ) + .await?; let affected = sqlx::query("DELETE FROM saved_query_folders WHERE id = ?") .bind(id) .execute(&self.pool) diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index ddd298a4c3..ecfc9fa358 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -324,15 +324,32 @@ impl SavedQueries { /// connection itself is removed. Its queries name tables only that /// database has. pub async fn delete_for_connection(&self, connection: Uuid) -> Result { - crate::query_history::trim_upgrade_copies( - &self.path, - &[crate::query_history::CopyDelete { - table: "saved_queries", - sql: "DELETE FROM main.saved_queries WHERE connection_id = ?".to_owned(), - binds: vec![crate::query_history::Bind::Text(connection.to_string())], - }], - ) - .await?; + // The copies an upgrade kept hold none of what the connection had. + let copies: Vec = [ + ( + "saved_queries", + "DELETE FROM main.saved_queries WHERE connection_id = ?", + ), + ( + "saved_query_folders", + "DELETE FROM main.saved_query_folders WHERE connection_id = ?", + ), + ( + "favourite_tables", + "DELETE FROM main.favourite_tables WHERE connection_id = ?", + ), + ( + "favourite_databases", + "DELETE FROM main.favourite_databases WHERE connection_id = ?", + ), + ] + .map(|(table, sql)| crate::query_history::CopyDelete { + table, + sql: sql.to_owned(), + binds: vec![crate::query_history::Bind::Text(connection.to_string())], + }) + .into(); + crate::query_history::trim_upgrade_copies(&self.path, &copies).await?; let affected = sqlx::query("DELETE FROM saved_queries WHERE connection_id = ?") .bind(connection.to_string()) .execute(&self.pool) diff --git a/core/docs/decisions/0017-favourites.md b/core/docs/decisions/0017-favourites.md index 84a2639c03..e6488904f1 100644 --- a/core/docs/decisions/0017-favourites.md +++ b/core/docs/decisions/0017-favourites.md @@ -23,7 +23,7 @@ The folders, the keywords, the order and the marked tables and databases live in ## Consequences -- A database an earlier build wrote is copied beside itself before the migration ([0012](0012-copies-before-a-format-upgrade.md)); a build before this one refuses it, as it refuses any newer one. The copies hold none of the new tables, since they are made from the older format, so deleting a folder or a favourite needs no trim of them. +- A database an earlier build wrote is copied beside itself before the migration ([0012](0012-copies-before-a-format-upgrade.md)); a build before this one refuses it, as it refuses any newer one. A copy made from the older format holds none of the new tables, but one a later migration makes holds them, so deleting a folder, a favourite or a connection's data trims the copies as a saved query's delete does, and the copies' sweep covers folders by id. - `SavedQuery` gains `keyword`, `folder_id` and `order`. `NewSavedQuery` is unchanged: a save keeps the keyword and the place of the query it replaces. - Not here: the macOS team library, linked folders and per-file favourites, which stay outside the core, and the FFI surface, which a later change adds when Windows or macOS shows favourites. - The Linux sidebar shows the folders, the keyword expansion and the marked tables and databases in later changes, each its own pull request. From ef4887db4073e4edffb99e75920bce38f6f0342c Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 19:57:20 +0700 Subject: [PATCH 09/23] fix(linux-sidebar): share saved query changes across favorites views --- Cargo.lock | 7 + core/crates/storage/src/query_history/mod.rs | 15 +- core/crates/storage/src/saved_queries/mod.rs | 159 ++++++++++++----- linux/crates/app/Cargo.toml | 2 +- .../src/services/saved_connection_editor.rs | 137 +++++++++++++-- .../app/src/ui/saved_queries_dialog/imp.rs | 5 + .../app/src/ui/saved_queries_dialog/mod.rs | 109 ++++++++---- .../app/src/ui/saved_queries_dialog/tests.rs | 109 +++++++++++- .../src/ui/session_window/import_from_app.rs | 43 ++++- .../session_window/resolve_file_identity.rs | 7 +- linux/crates/app/src/ui/workspace/imp.rs | 2 + linux/crates/app/src/ui/workspace/mod.rs | 12 +- .../ui/workspace/sidebar/favorites_pane.rs | 161 ++++++++++++++++-- .../app/src/ui/workspace/status_pages.rs | 65 +++++-- .../app/src/ui/workspace/workspace_shell.rs | 159 ++++++++++++++--- .../src/ui/workspace/workspace_shell_imp.rs | 4 + linux/docs/storage.md | 20 +++ linux/po/POTFILES.in | 1 + 18 files changed, 854 insertions(+), 163 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 143208cf07..0895ceb38c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6870,6 +6870,12 @@ dependencies = [ "digest 0.11.3", ] +[[package]] +name = "sha1_smol" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d" + [[package]] name = "sha2" version = "0.10.9" @@ -9133,6 +9139,7 @@ dependencies = [ "getrandom 0.4.3", "js-sys", "serde_core", + "sha1_smol", "wasm-bindgen", ] diff --git a/core/crates/storage/src/query_history/mod.rs b/core/crates/storage/src/query_history/mod.rs index 04615093a9..b03f8f2c9d 100644 --- a/core/crates/storage/src/query_history/mod.rs +++ b/core/crates/storage/src/query_history/mod.rs @@ -13,10 +13,12 @@ mod search_fold; mod status_filter; use std::path::{Path, PathBuf}; +use std::sync::Arc; use std::time::SystemTime; use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions}; use sqlx::{AssertSqlSafe, ConnectOptions, Connection, Row, SqlitePool}; +use tokio::sync::watch; use uuid::Uuid; use crate::error::StorageError; @@ -63,6 +65,8 @@ pub(crate) enum Bind { pub struct QueryHistory { pool: SqlitePool, path: PathBuf, + // Shared by every handle `saved_queries` gives out, so a write through one reaches the others' followers. + saved_changes: Arc>, } impl QueryHistory { @@ -87,18 +91,19 @@ impl QueryHistory { crate::upgrade_copies::keep_database(&pool, &path, version).await?; } schema::migrate(&pool).await?; - Ok(Self { pool, path }) + Ok(Self { + pool, + path, + saved_changes: Arc::new(watch::channel(0).0), + }) } pub fn path(&self) -> &Path { &self.path } - /// The saved queries, which share this database. One file, one - /// migration chain, one open: what the user keeps and what they - /// ran are the same kind of thing in the same place. pub fn saved_queries(&self) -> crate::saved_queries::SavedQueries { - crate::saved_queries::SavedQueries::new(self.pool.clone(), self.path.clone()) + crate::saved_queries::SavedQueries::new(self.pool.clone(), self.path.clone(), self.saved_changes.clone()) } pub async fn record(&self, entry: NewEntry) -> Result { diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index 4a4a00737c..f2dd7a7899 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -1,9 +1,11 @@ mod new_saved_query; mod saved_query; +use std::sync::Arc; use std::time::SystemTime; -use sqlx::{Row, SqlitePool}; +use sqlx::{AssertSqlSafe, Connection, Row, SqlitePool}; +use tokio::sync::watch; use uuid::Uuid; use crate::error::StorageError; @@ -12,44 +14,38 @@ use crate::unix_time::{from_unix, to_unix}; pub use new_saved_query::NewSavedQuery; pub use saved_query::SavedQuery; -/// What a save did, so the caller can say which. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SaveOutcome { pub id: i64, - /// The name was already in use on this connection and its query - /// was overwritten. pub replaced: bool, } -/// The cap the query history puts on one entry, applied here too: a -/// saved query is the same kind of text and the same reasons apply. const MAX_QUERY_BYTES: usize = 1024 * 1024; -/// A name long enough to be unreadable in the list is a name nobody -/// meant to type. const MAX_NAME_CHARS: usize = 200; -/// The user's named queries. Cloning shares the pool with the query -/// history it lives beside. #[derive(Debug, Clone)] pub struct SavedQueries { pool: SqlitePool, // The database's file, whose upgrade copies a delete reaches too. path: std::path::PathBuf, + changes: Arc>, } impl SavedQueries { - pub(crate) fn new(pool: SqlitePool, path: std::path::PathBuf) -> Self { - Self { pool, path } + pub(crate) fn new(pool: SqlitePool, path: std::path::PathBuf, changes: Arc>) -> Self { + Self { pool, path, changes } + } + + pub fn changes(&self) -> watch::Receiver { + self.changes.subscribe() + } + + fn changed(&self) { + self.changes + .send_modify(|revision| *revision = revision.wrapping_add(1)); } - /// Keep `query` under its name, replacing whatever that name held - /// for this connection. - /// - /// Saving under a name already in use overwrites it, because that - /// is what the user is asking for: the same report, fixed. The - /// caller is expected to have confirmed the overwrite, which it - /// can see coming from `list`. pub async fn save(&self, query: NewSavedQuery) -> Result { let name = query.name.trim(); if name.is_empty() { @@ -68,14 +64,14 @@ impl SavedQueries { }); } let now = to_unix(SystemTime::now()); - // Asked before the write, because afterwards there is no way to - // tell an insert from an overwrite: only one connection is ever - // open on this pool, so nothing can slip in between. + // Hold the write lock across both statements, so concurrent saves agree on which inserted. + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; let replaced: bool = sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM saved_queries WHERE connection_id = ? AND name = ?") .bind(query.connection_id.to_string()) .bind(name) - .fetch_one(&self.pool) + .fetch_one(&mut *transaction) .await? > 0; let id = sqlx::query( @@ -95,9 +91,11 @@ impl SavedQueries { .bind(&query.connection_name) .bind(now) .bind(now) - .fetch_one(&self.pool) + .fetch_one(&mut *transaction) .await? .try_get("id")?; + transaction.commit().await?; + self.changed(); Ok(SaveOutcome { id, replaced }) } @@ -137,15 +135,14 @@ impl SavedQueries { .bind(now) .fetch_optional(&self.pool) .await?; - Ok(match inserted { - Some(row) => Some(row.try_get("id")?), - None => None, - }) + let Some(row) = inserted else { + return Ok(None); + }; + let id = row.try_get("id")?; + self.changed(); + Ok(Some(id)) } - /// Everything saved against `connection`, or everything at all when - /// no connection is given. Ordered by name, because the user - /// looking for one knows what they called it. pub async fn list(&self, connection: Option) -> Result, StorageError> { let rows = match connection { Some(id) => { @@ -180,9 +177,6 @@ impl SavedQueries { row.map(row_to_saved_query).transpose() } - /// Give a saved query a different name. Fails when the connection - /// already has one under that name, which is the caller's cue to - /// say so rather than silently merge two queries into one. pub async fn rename(&self, id: i64, name: &str) -> Result<(), StorageError> { let name = name.trim(); if name.is_empty() { @@ -205,10 +199,11 @@ impl SavedQueries { _ => StorageError::Database(error), })? .rows_affected(); - match affected { - 0 => Err(StorageError::NotFound), - _ => Ok(()), + if affected == 0 { + return Err(StorageError::NotFound); } + self.changed(); + Ok(()) } pub async fn delete(&self, id: i64) -> Result<(), StorageError> { @@ -226,15 +221,13 @@ impl SavedQueries { .execute(&self.pool) .await? .rows_affected(); - match affected { - 0 => Err(StorageError::NotFound), - _ => Ok(()), + if affected == 0 { + return Err(StorageError::NotFound); } + self.changed(); + Ok(()) } - /// Drop everything saved against a connection, for when the - /// connection itself is removed. Its queries name tables only that - /// database has. pub async fn delete_for_connection(&self, connection: Uuid) -> Result { crate::query_history::trim_upgrade_copies( &self.path, @@ -250,6 +243,9 @@ impl SavedQueries { .execute(&self.pool) .await? .rows_affected(); + if affected > 0 { + self.changed(); + } Ok(affected as usize) } } @@ -356,6 +352,22 @@ mod tests { assert_eq!(all[0].query, "SELECT 2"); } + #[tokio::test] + async fn concurrent_saves_report_exactly_one_replacement_and_keep_the_id() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + let (first, second) = tokio::join!( + store.save(new_query("daily", "SELECT 1", connection)), + store.save(new_query("daily", "SELECT 2", connection)), + ); + let first = first.expect("first save"); + let second = second.expect("second save"); + assert_ne!(first.replaced, second.replaced); + assert_eq!(first.id, second.id); + assert_eq!(store.list(Some(connection)).await.expect("list").len(), 1); + } + #[tokio::test] async fn the_same_name_on_another_connection_is_another_query() { let root = tempfile::tempdir().expect("tempdir"); @@ -534,6 +546,67 @@ mod tests { assert_eq!(store.list(Some(staying)).await.expect("list").len(), 1); } + #[tokio::test] + async fn every_write_moves_the_revision_every_handle_follows() { + let root = tempfile::tempdir().expect("tempdir"); + let paths = StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro"); + let history = QueryHistory::open(&paths).await.expect("open"); + let (writer, follower) = (history.saved_queries(), history.saved_queries()); + let mut changes = follower.changes(); + let connection = Uuid::new_v4(); + let mut moved = || { + let moved = changes.has_changed().expect("the sender lives"); + changes.mark_unchanged(); + moved + }; + + let saved = writer + .save(new_query("daily", "SELECT 1", connection)) + .await + .expect("save"); + assert!(moved(), "a save"); + writer + .save_if_new(new_query("weekly", "SELECT 2", connection)) + .await + .expect("save if new"); + assert!(moved(), "a save of a new name"); + writer.rename(saved.id, "nightly").await.expect("rename"); + assert!(moved(), "a rename"); + writer.delete(saved.id).await.expect("delete"); + assert!(moved(), "a delete"); + writer + .delete_for_connection(connection) + .await + .expect("delete for connection"); + assert!(moved(), "a connection's queries removed"); + } + + #[tokio::test] + async fn a_read_or_a_write_that_changed_nothing_leaves_the_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + store + .save(new_query("daily", "SELECT 1", connection)) + .await + .expect("save"); + let changes = store.changes(); + + store.list(Some(connection)).await.expect("list"); + store + .save_if_new(new_query("daily", "SELECT 2", connection)) + .await + .expect("save if new"); + store.rename(404, "gone").await.expect_err("no such query"); + store.delete(404).await.expect_err("no such query"); + store + .delete_for_connection(Uuid::new_v4()) + .await + .expect("delete for a connection with none"); + + assert!(!changes.has_changed().expect("the sender lives")); + } + #[tokio::test] async fn a_save_carries_the_connections_current_name() { let root = tempfile::tempdir().expect("tempdir"); diff --git a/linux/crates/app/Cargo.toml b/linux/crates/app/Cargo.toml index 8a8fd21ecf..6600fedccc 100644 --- a/linux/crates/app/Cargo.toml +++ b/linux/crates/app/Cargo.toml @@ -100,7 +100,7 @@ tracing.workspace = true tracing-subscriber.workspace = true # Cells a value takes in the grid's monospace font. unicode-width.workspace = true -uuid.workspace = true +uuid = { workspace = true, features = ["v5"] } gettext-rs = { version = "0.8", features = ["gettext-system"] } # Counts grouped the way the user's locale groups digits. icu_decimal = { version = "2.3", features = ["alloc"] } diff --git a/linux/crates/app/src/services/saved_connection_editor.rs b/linux/crates/app/src/services/saved_connection_editor.rs index 9e057b1fb2..f2dab11097 100644 --- a/linux/crates/app/src/services/saved_connection_editor.rs +++ b/linux/crates/app/src/services/saved_connection_editor.rs @@ -262,24 +262,35 @@ impl SavedConnectionEditor { // A delete from another window purges a connection's queries once; any this import saves for // it afterwards are removed again here. - pub async fn save_imported_queries(&self, applied: &AppliedImport, store: &SavedQueries) -> QueryImportOutcome { + pub async fn save_imported_queries( + &self, + applied: &AppliedImport, + store: &SavedQueries, + ) -> Result { let outcome = save_queries(applied, store).await; - if let Ok(list) = self.list().await { - let mut gone: Vec = applied - .queries - .iter() - .map(|query| query.query.connection_id) - .filter(|id| !list.iter().any(|saved| saved.id == *id)) - .collect(); - gone.sort_unstable(); - gone.dedup(); - for id in gone { - if let Err(error) = store.delete_for_connection(id).await { - tracing::warn!(%error, "queries imported for a deleted connection are still saved"); - } + let list = self.list().await?; + let mut gone: Vec = applied + .queries + .iter() + .map(|query| query.query.connection_id) + .filter(|id| !list.iter().any(|saved| saved.id == *id)) + .collect(); + gone.sort_unstable(); + gone.dedup(); + let mut failure = None; + for &id in &gone { + if let Err(error) = store.delete_for_connection(id).await { + failure.get_or_insert(SavedConnectionError::Storage(error)); } } - outcome + if let Some(error) = failure { + return Err(error); + } + // Removed queries must not be reported as successfully imported. + if let Some(&id) = gone.first() { + return Err(SavedConnectionError::NotFound(id)); + } + Ok(outcome) } /// A pick of the group it is already in writes nothing. @@ -1454,4 +1465,100 @@ mod tests { assert_eq!(names, ["Prod", "Prod (Copy)", "Stage", "Test"]); assert_eq!(copy.order, 1); } + fn imported_query(id: Uuid) -> AppliedImport { + AppliedImport { + queries: vec![tablepro_foreign_import::review::ImportedQuery { + reference: "report".to_owned(), + query: tablepro_storage::saved_queries::NewSavedQuery { + name: "Report".to_owned(), + query: "SELECT 1".to_owned(), + connection_id: id, + connection_name: "Prod".to_owned(), + }, + }], + ..AppliedImport::default() + } + } + + async fn query_store(fixture: &Fixture) -> SavedQueries { + let paths = StoragePaths::under(fixture._root.path(), "tablepro-test", "app.tablepro.Test"); + tablepro_storage::QueryHistory::open(&paths) + .await + .expect("history") + .saved_queries() + } + + #[tokio::test] + async fn an_import_does_not_report_queries_removed_with_their_connection_as_added() { + let fixture = fixture().await; + let queries = query_store(&fixture).await; + let applied = imported_query(fixture.saved.id); + fixture + .store + .remove_blocking(fixture.saved.id) + .expect("connection removed"); + let result = fixture.editor.save_imported_queries(&applied, &queries).await; + assert!(matches!(result, Err(SavedConnectionError::NotFound(id)) if id == fixture.saved.id)); + assert!(queries.list(None).await.expect("queries").is_empty()); + } + + #[tokio::test] + async fn an_import_reports_a_connection_list_read_failure() { + let fixture = fixture().await; + let queries = query_store(&fixture).await; + let applied = imported_query(fixture.saved.id); + std::fs::remove_file(fixture.store.path()).expect("remove connection file"); + std::fs::create_dir(fixture.store.path()).expect("unreadable connection file"); + let paths = StoragePaths::under(fixture._root.path(), "tablepro-test", "app.tablepro.Test"); + let editor = SavedConnectionEditor::new(ConnectionStore::new(&paths), fixture.vault.clone(), paused_tasks()); + let result = editor.save_imported_queries(&applied, &queries).await; + assert!(matches!(result, Err(SavedConnectionError::Storage(_)))); + } + + #[tokio::test] + async fn an_import_reports_failure_to_remove_queries_of_a_deleted_connection() { + use tablepro_core::statement::{GuardedStatement, StatementBuilder}; + use tablepro_core::{ + CallOptions, ConnectEnvironment, ConnectOptions, ConnectTarget, DatabaseDriver, FileEndpoint, + ForeignKeyMode, TableRef, WorkspaceSettings, WriteBatch, WriteKind, + }; + use tokio_util::sync::CancellationToken; + + let fixture = fixture().await; + let queries = query_store(&fixture).await; + let paths = StoragePaths::under(fixture._root.path(), "tablepro-test", "app.tablepro.Test"); + let options = ConnectOptions { + target: ConnectTarget::File(FileEndpoint::open_existing(paths.history_database()).expect("history file")), + workspace_settings: WorkspaceSettings::workspace(false), + liveness: tablepro_core::LivenessPolicy::DESKTOP, + environment: ConnectEnvironment::new("test"), + }; + let mut trigger = StatementBuilder::new(); + trigger.push_sql("CREATE TRIGGER refuse_delete BEFORE DELETE ON saved_queries BEGIN SELECT RAISE(ABORT, 'test refuses delete'); END"); + let batch = WriteBatch::new( + WriteKind::SchemaChanges, + TableRef::unqualified("saved_queries"), + vec![GuardedStatement::unguarded(trigger.finish())], + ForeignKeyMode::Enforced, + ); + let connection = tablepro_driver_sqlite::SqliteDriver + .connect(options, CancellationToken::new()) + .await + .expect("connect"); + connection + .write_batch(&batch, CallOptions::new(None, CancellationToken::new())) + .await + .expect("trigger"); + connection.close().await.expect("close"); + fixture + .store + .remove_blocking(fixture.saved.id) + .expect("connection removed"); + let result = fixture + .editor + .save_imported_queries(&imported_query(fixture.saved.id), &queries) + .await; + assert!(matches!(result, Err(SavedConnectionError::Storage(_)))); + assert_eq!(queries.list(None).await.expect("queries").len(), 1); + } } diff --git a/linux/crates/app/src/ui/saved_queries_dialog/imp.rs b/linux/crates/app/src/ui/saved_queries_dialog/imp.rs index dfc972cb81..86e46f21e7 100644 --- a/linux/crates/app/src/ui/saved_queries_dialog/imp.rs +++ b/linux/crates/app/src/ui/saved_queries_dialog/imp.rs @@ -31,6 +31,7 @@ pub struct SavedQueriesDialog { pub retry_button: TemplateChild, pub(super) parts: OnceCell, + pub(super) changes: RefCell>, pub(super) snapshot: RefCell, pub(super) search_generation: Cell, pub(super) load_generation: Cell, @@ -54,6 +55,10 @@ impl ObjectSubclass for SavedQueriesDialog { } impl ObjectImpl for SavedQueriesDialog { + fn dispose(&self) { + self.changes.take(); + } + fn signals() -> &'static [Signal] { static SIGNALS: OnceLock> = OnceLock::new(); SIGNALS.get_or_init(|| { diff --git a/linux/crates/app/src/ui/saved_queries_dialog/mod.rs b/linux/crates/app/src/ui/saved_queries_dialog/mod.rs index e1b6a6eff8..404f3473c4 100644 --- a/linux/crates/app/src/ui/saved_queries_dialog/mod.rs +++ b/linux/crates/app/src/ui/saved_queries_dialog/mod.rs @@ -16,12 +16,12 @@ use gtk4::subclass::prelude::*; use gtk4::{gio, glib}; use libadwaita as adw; use libadwaita::prelude::*; -use tablepro_session::runtime::{TaskFailure, Tasks}; +use tablepro_session::runtime::{ProcessHold, TaskFailure, Tasks, WatchForwarder}; use tablepro_storage::{SavedQueries, StorageError}; use uuid::Uuid; use crate::i18n::{gettext, gettext_f}; -use crate::runtime::spawn_and_deliver; +use crate::runtime::{spawn_and_deliver, spawn_held}; use crate::ui::history_dialog::QueryDestination; use saved_query_listing::{Listing, matches}; use saved_query_object::SavedQueryObject; @@ -38,6 +38,7 @@ pub(crate) struct SavedQueriesDialogInit { // Its connection's queries are listed first. pub active_connection: Option, pub tasks: Tasks, + pub hold: Rc, } // What the last search matched. None shows every query. @@ -47,6 +48,8 @@ struct DialogParts { store: Option, active_connection: Option, tasks: Tasks, + hold: Rc, + selection: gtk::SingleSelection, items: gio::ListStore, matched: Matched, filter: gtk::CustomFilter, @@ -78,10 +81,18 @@ impl SavedQueriesDialog { let filtered = gtk::FilterListModel::new(Some(items.clone()), Some(filter.clone())); let sorted = gtk::SortListModel::new(Some(filtered), None::); sorted.set_section_sorter(Some(&by_group())); + let selection = gtk::SingleSelection::builder() + .model(&sorted) + .autoselect(false) + .can_unselect(true) + .build(); + let changes = init.store.as_ref().map(SavedQueries::changes); let _ = dialog.imp().parts.set(DialogParts { store: init.store, active_connection: init.active_connection, tasks: init.tasks, + hold: init.hold, + selection, items, matched, filter, @@ -89,8 +100,28 @@ impl SavedQueriesDialog { }); dialog.setup_list(); dialog.connect_controls(); - dialog.show_results(); - dialog.load(); + let loading = adw::StatusPage::builder() + .title(gettext("Loading Saved Queries")) + .paintable(&adw::SpinnerPaintable::new(Some(&dialog))) + .build(); + dialog.imp().stack.add_named(&loading, Some("loading")); + dialog.imp().stack.set_visible_child_name("loading"); + if let Some(changes) = changes { + let weak = dialog.downgrade(); + dialog.imp().changes.replace(Some(WatchForwarder::new( + changes, + move |_| { + if let Some(dialog) = weak.upgrade() { + dialog.load(); + } + }, + |future| { + glib::spawn_future_local(future); + }, + ))); + } else { + dialog.load_failed(); + } dialog } @@ -112,7 +143,7 @@ impl SavedQueriesDialog { return; }; let list_view = imp.list_view.get(); - list_view.set_model(Some(>k::NoSelection::new(Some(parts.sorted.clone())))); + list_view.set_model(Some(&parts.selection)); list_view.set_factory(Some(&self.row_factory())); list_view.set_header_factory(Some(&connection_header_factory())); let dialog = self.downgrade(); @@ -319,8 +350,6 @@ impl SavedQueriesDialog { self.change(StoreChange::Delete, move |store| async move { store.delete(id).await }); } - // The list is read again whether the change landed or not, so it - // shows what the store holds now. fn change(&self, change: StoreChange, work: impl FnOnce(SavedQueries) -> W + Send + 'static) where W: Future> + Send + 'static, @@ -331,31 +360,32 @@ impl SavedQueriesDialog { let Some(store) = parts.store.clone() else { return; }; + let (send, received) = tokio::sync::oneshot::channel(); + spawn_held(&parts.tasks, parts.hold.as_ref(), async move { + let _ = send.send(work(store).await); + }); let dialog = self.downgrade(); - drop(spawn_and_deliver( - &parts.tasks, - async move { work(store).await }, - move |done| { - let Some(dialog) = dialog.upgrade() else { - return; - }; - let failure = match done { - Ok(Ok(())) => None, - Ok(Err(error)) => { - tracing::warn!(%error, ?change, "a saved query change failed"); - Some(change.failure_text(Some(&error))) - } - Err(failure) => { - tracing::warn!(%failure, ?change, "a saved query change did not finish"); - Some(change.failure_text(None)) - } - }; - if let Some(message) = failure { - dialog.add_toast(&message); + glib::spawn_future_local(async move { + let done = received.await; + let Some(dialog) = dialog.upgrade() else { + return; + }; + let failure = match done { + Ok(Ok(())) => None, + Ok(Err(error)) => { + tracing::warn!(%error, ?change, "a saved query change failed"); + Some(change.failure_text(Some(&error))) } + Err(failure) => { + tracing::warn!(%failure, ?change, "a saved query change did not finish"); + Some(change.failure_text(None)) + } + }; + if let Some(message) = failure { + dialog.add_toast(&message); dialog.load(); - }, - )); + } + }); } fn load(&self) { @@ -402,6 +432,11 @@ impl SavedQueriesDialog { let Some(parts) = imp.parts.get() else { return; }; + let selected = parts + .selection + .selected_item() + .and_downcast::() + .and_then(|object| object.id()); let objects: Vec = listing .queries .into_iter() @@ -412,6 +447,19 @@ impl SavedQueriesDialog { imp.listed.set(true); // The ids the search matched may have changed with the list. self.search(); + if let Some(id) = selected { + let position = (0..parts.sorted.n_items()).find(|&position| { + parts + .sorted + .item(position) + .and_downcast::() + .and_then(|object| object.id()) + == Some(id) + }); + parts + .selection + .set_selected(position.unwrap_or(gtk::INVALID_LIST_POSITION)); + } self.show_results(); } @@ -475,8 +523,7 @@ impl SavedQueriesDialog { let Some(parts) = imp.parts.get() else { return; }; - // Only a read that lands takes the list off the error page. - if !imp.listed.get() && imp.stack.visible_child_name().as_deref() == Some("error") { + if !imp.listed.get() { return; } if parts.sorted.n_items() > 0 { diff --git a/linux/crates/app/src/ui/saved_queries_dialog/tests.rs b/linux/crates/app/src/ui/saved_queries_dialog/tests.rs index 74c27ce3d7..b883ce1e01 100644 --- a/linux/crates/app/src/ui/saved_queries_dialog/tests.rs +++ b/linux/crates/app/src/ui/saved_queries_dialog/tests.rs @@ -22,6 +22,7 @@ const WAIT: Duration = Duration::from_secs(30); struct Harness { runtime: AppRuntime, + hold: Rc, store: SavedQueries, root: tempfile::TempDir, } @@ -53,6 +54,7 @@ impl Harness { }); Self { runtime: test_runtime(), + hold: Rc::new(tablepro_session::runtime::CountingHold::new()), store, root, } @@ -63,6 +65,7 @@ impl Harness { store: Some(self.store.clone()), active_connection, tasks: self.runtime.tasks(), + hold: self.hold.clone(), }) } } @@ -335,6 +338,7 @@ fn deleting_a_query_takes_it_out_of_the_list() { let id = named(&dialog, "daily orders").id().expect("an id"); dialog.delete(id); + assert_eq!(harness.hold.live(), 1, "deletion holds the process"); wait_until(WAIT, || row_titles(&dialog) == ["stale carts"]).expect("the deleted query stayed in the list"); } @@ -347,6 +351,7 @@ fn renaming_a_query_lists_it_under_its_new_name() { let id = named(&dialog, "daily orders").id().expect("an id"); dialog.rename(id, "weekly orders".to_owned()); + assert_eq!(harness.hold.live(), 1, "rename holds the process"); wait_until(WAIT, || row_titles(&dialog) == ["weekly orders", "stale carts"]).expect("the new name"); } @@ -452,19 +457,19 @@ fn copying_a_query_says_so_inside_the_dialog() { } #[gtk4::test] -fn a_dialog_with_no_database_shows_the_empty_state_rather_than_failing() { +fn a_dialog_with_no_database_shows_an_error() { init(); let runtime = test_runtime(); let dialog = SavedQueriesDialog::new(SavedQueriesDialogInit { store: None, active_connection: None, tasks: runtime.tasks(), + hold: Rc::new(tablepro_session::runtime::CountingHold::new()), }); drain_main_context(); - assert_eq!(visible_page(&dialog).as_deref(), Some("empty")); - assert_eq!(dialog.imp().status_page.title(), "No Saved Queries"); + assert_eq!(visible_page(&dialog).as_deref(), Some("error")); assert!(row_titles(&dialog).is_empty()); } @@ -488,3 +493,101 @@ fn a_rename_failure_says_what_went_wrong() { fn every_row_menu_item_has_an_access_key_of_its_own() { assert_access_keys(&row_menu()); } + +#[gtk4::test] +fn a_change_keeps_the_process_until_it_lands_after_the_dialog_is_gone() { + let (harness, local, _) = seeded(); + let dialog = harness.dialog(Some(local)); + wait_until(WAIT, || row_titles(&dialog).len() == 2).expect("queries listed"); + let id = named(&dialog, "daily orders").id().expect("id"); + let (finish, finished) = tokio::sync::oneshot::channel(); + dialog.change(StoreChange::Rename, move |store| async move { + let _ = finished.await; + store.rename(id, "weekly orders").await + }); + assert_eq!(harness.hold.live(), 1); + drop(dialog); + drain_main_context(); + assert_eq!(harness.hold.live(), 1); + finish.send(()).expect("release write"); + wait_until(WAIT, || harness.hold.live() == 0).expect("write finished"); + let store = harness.store.clone(); + let read = harness.runtime.tasks().spawn_task(async move { store.get(id).await }); + let query = crate::test_support::finish_on_main(WAIT, read) + .expect("read finished") + .expect("task") + .expect("read") + .expect("query"); + assert_eq!(query.name, "weekly orders"); +} + +#[gtk4::test] +fn external_changes_reach_the_dialog_and_keep_selection_by_id() { + let (harness, local, _) = seeded(); + let dialog = harness.dialog(Some(local)); + wait_until(WAIT, || row_titles(&dialog).len() == 2).expect("queries listed"); + let id = named(&dialog, "daily orders").id().expect("id"); + dialog.imp().parts.get().expect("parts").selection.set_selected(0); + let store = harness.store.clone(); + let change = harness + .runtime + .tasks() + .spawn_task(async move { store.rename(id, "weekly orders").await }); + crate::test_support::finish_on_main(WAIT, change) + .expect("rename finished") + .expect("task") + .expect("rename"); + wait_until(WAIT, || row_titles(&dialog) == ["weekly orders", "stale carts"]).expect("external rename listed"); + let selected = dialog + .imp() + .parts + .get() + .expect("parts") + .selection + .selected_item() + .and_downcast::() + .and_then(|object| object.id()); + assert_eq!(selected, Some(id)); + let store = harness.store.clone(); + let change = harness + .runtime + .tasks() + .spawn_task(async move { store.delete(id).await }); + crate::test_support::finish_on_main(WAIT, change) + .expect("delete finished") + .expect("task") + .expect("delete"); + wait_until(WAIT, || row_titles(&dialog) == ["stale carts"]).expect("external deletion listed"); + assert!( + dialog + .imp() + .parts + .get() + .expect("parts") + .selection + .selected_item() + .is_none() + ); +} + +#[gtk4::test] +fn a_replaced_read_cannot_replace_the_current_list() { + let (harness, local, _) = seeded(); + let dialog = harness.dialog(Some(local)); + wait_until(WAIT, || row_titles(&dialog).len() == 2).expect("queries listed"); + let old = dialog.imp().load_generation.get(); + dialog.load(); + dialog.list_arrived(old, Ok(Ok(Listing::new(Vec::new(), Some(local))))); + assert_eq!(row_titles(&dialog).len(), 2); +} + +#[gtk4::test] +fn an_initial_read_never_claims_the_list_is_empty() { + let (harness, local, _) = seeded(); + let dialog = harness.dialog(Some(local)); + assert_eq!(visible_page(&dialog).as_deref(), Some("loading")); + dialog.apply_matches(Some(HashSet::new())); + assert_eq!(visible_page(&dialog).as_deref(), Some("loading")); + wait_until(WAIT, || row_titles(&dialog).len() == 2).expect("queries listed"); + assert_eq!(visible_page(&dialog).as_deref(), Some("list")); +} diff --git a/linux/crates/app/src/ui/session_window/import_from_app.rs b/linux/crates/app/src/ui/session_window/import_from_app.rs index 95d04e3d0d..a68fbaf1a3 100644 --- a/linux/crates/app/src/ui/session_window/import_from_app.rs +++ b/linux/crates/app/src/ui/session_window/import_from_app.rs @@ -67,7 +67,7 @@ impl SessionWindow { pub(super) fn imported_message( imported: &ImportedFromApp, - queries: Option, + queries: Option>, queries_available: bool, ) -> String { let connections = imported.applied.connections.len(); @@ -80,7 +80,7 @@ pub(super) fn imported_message( &[("n", &connections.to_string())], )); } - if let Some(queries) = queries { + if let Some(Ok(queries)) = &queries { if queries.added > 0 { parts.push(ngettext_f( "Added {n} saved query.", @@ -97,6 +97,14 @@ pub(super) fn imported_message( &[("n", &queries.failed.to_string())], )); } + } else if let Some(Err(error)) = queries { + tracing::warn!(%error, "saved query import could not finish"); + parts.push(match error { + SavedConnectionError::NotFound(_) => { + gettext("Saved query import was interrupted because a connection was deleted.") + } + _ => gettext("Saved query import could not finish. Some queries may have been saved."), + }); } else if !queries_available && !imported.applied.queries.is_empty() { parts.push(gettext( "Saved queries were not added: the query history is not available.", @@ -115,3 +123,34 @@ pub(super) fn imported_message( } parts.join(" ") } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn query_cleanup_failures_are_visible_without_claiming_success() { + let imported = ImportedFromApp { + applied: Default::default(), + secrets_not_kept: 0, + }; + let message = imported_message( + &imported, + Some(Err(SavedConnectionError::Storage(StorageError::NotInitialised))), + true, + ); + assert_eq!( + message, + "Saved query import could not finish. Some queries may have been saved." + ); + let message = imported_message( + &imported, + Some(Err(SavedConnectionError::NotFound(uuid::Uuid::new_v4()))), + true, + ); + assert_eq!( + message, + "Saved query import was interrupted because a connection was deleted." + ); + } +} diff --git a/linux/crates/app/src/ui/session_window/resolve_file_identity.rs b/linux/crates/app/src/ui/session_window/resolve_file_identity.rs index 0f1315169d..3b32c21203 100644 --- a/linux/crates/app/src/ui/session_window/resolve_file_identity.rs +++ b/linux/crates/app/src/ui/session_window/resolve_file_identity.rs @@ -37,7 +37,8 @@ pub(crate) fn file_request( let endpoint = FileEndpoint::open_existing(path).map_err(DriverError::from)?; let mut request = ConnectRequest { metadata: ConnectionMetadata { - id: uuid::Uuid::new_v4(), + // Saved queries must remain attached when the same file is opened again. + id: uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_URL, identity.uri.as_bytes()), name, driver_id: driver.id().to_owned(), }, @@ -100,6 +101,10 @@ mod tests { let request = file_request(&identity, &drivers, b"", false).expect("a request"); let read_only = file_request(&identity, &drivers, b"", true).expect("a read-only request"); + assert_eq!(request.metadata.id, read_only.metadata.id); + let other = FileIdentity::new(Some(PathBuf::from("/srv/other.db")), "file:///srv/other.db".to_owned()); + let other = file_request(&other, &drivers, b"", false).expect("other request"); + assert_ne!(request.metadata.id, other.metadata.id); assert_eq!(request.metadata.name, "app.db"); assert!(matches!(request.target, RequestTarget::File(_))); assert!(!request.workspace_settings.read_only); diff --git a/linux/crates/app/src/ui/workspace/imp.rs b/linux/crates/app/src/ui/workspace/imp.rs index 0b49c662f1..8a267028de 100644 --- a/linux/crates/app/src/ui/workspace/imp.rs +++ b/linux/crates/app/src/ui/workspace/imp.rs @@ -56,6 +56,8 @@ pub struct Workspace { pub(super) assistant_available: Cell, pub(super) key: OnceCell, + // The connection id its saved queries are kept under, which the editor's Save Query writes with. + pub(super) connection_id: OnceCell, pub(super) data_model: OnceCell, /// Which tab each of the session's pages shows, shared with the /// model, so the shell can tell whose a page is while the model is diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 429e700d83..44d49513ab 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -546,8 +546,6 @@ pub(crate) enum WorkspaceInput { ShowHistory, ShowSavedQueries, ActiveTab(workspace_tabs::ActiveTabCommand), - /// A query was saved or replaced: the sidebar's favorites read again. - SavedQueriesChanged, SaveQueryNamed { name: String, query: String, @@ -820,6 +818,7 @@ impl Workspace { let input = workspace.pump_inputs(); let _ = imp.sender.set(input.clone()); let _ = imp.key.set(key.clone()); + let _ = imp.connection_id.set(session.metadata().id); let context = session_slot(&context, &session); let storage = services.storage.clone(); let tasks = services.tasks.clone(); @@ -941,6 +940,10 @@ impl Workspace { self.imp().key.get().cloned() } + pub(crate) fn connection_id(&self) -> Option { + self.imp().connection_id.get().copied() + } + /// What the session's engine holds, which names the page with no /// tab open. pub(crate) fn data_model(&self) -> Option { @@ -1408,11 +1411,6 @@ impl WorkspaceModel { WorkspaceInput::ImportCsvRun(import) => self.on_import_csv_run(*import), WorkspaceInput::ActiveTab(command) => self.on_active_tab_command(command), WorkspaceInput::SaveQueryNamed { name, query } => self.on_save_query_named(name, query), - WorkspaceInput::SavedQueriesChanged => { - if let Some(shell) = self.shell.upgrade() { - shell.reload_favorites(); - } - } WorkspaceInput::OpenHistoryQuery(text) => self.open_editor_tab(Some(text)), WorkspaceInput::ReplaceActiveTabQuery(text) => self.on_replace_active_tab_query(text), WorkspaceInput::RefreshPage => self.on_refresh_active_tab(), diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 63edde2377..6f7c41dbdf 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -1,7 +1,3 @@ -//! The sidebar's Favorites scope: the named queries the user kept for the -//! connection in front, as the macOS sidebar lists them beside its -//! tables. Activating one opens it in a new query tab. - use std::rc::Rc; use gtk4 as gtk; @@ -15,24 +11,27 @@ use crate::i18n::gettext; const LIST: &str = "list"; const EMPTY: &str = "empty"; -/// What activating a favorite asks for: its SQL. type Opened = Rc; #[derive(Clone)] pub(crate) struct FavoritesPane { stack: gtk::Stack, store: gio::ListStore, + selection: gtk::SingleSelection, + error: adw::StatusPage, + retry: gtk::Button, + stale: adw::Banner, } impl FavoritesPane { - pub(crate) fn new(opened: impl Fn(String) + 'static) -> Self { + pub(crate) fn new(opened: impl Fn(String) + 'static, retry: impl Fn() + 'static) -> Self { let store = gio::ListStore::new::(); let selection = gtk::SingleSelection::builder() .model(&store) .autoselect(false) .can_unselect(true) .build(); - let list = gtk::ListView::new(Some(selection), Some(factory())); + let list = gtk::ListView::new(Some(selection.clone()), Some(factory())); list.add_css_class("navigation-sidebar"); list.set_single_click_activate(true); list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); @@ -47,27 +46,111 @@ impl FavoritesPane { .hscrollbar_policy(gtk::PolicyType::Never) .child(&list) .build(); + let retry = Rc::new(retry); + let retry_button = gtk::Button::with_label(&gettext("Try Again")); + retry_button.set_halign(gtk::Align::Center); + retry_button.connect_clicked({ + let retry = retry.clone(); + move |_| retry() + }); + let error = adw::StatusPage::builder() + .title(gettext("Favorites Unavailable")) + .icon_name("dialog-warning-symbolic") + .child(&retry_button) + .build(); + error.add_css_class("compact"); + let stale = adw::Banner::builder() + .title(gettext("Favorites could not be refreshed.")) + .button_label(gettext("Try Again")) + .build(); + stale.connect_button_clicked(move |_| retry()); + let content = gtk::Box::new(gtk::Orientation::Vertical, 0); + content.append(&stale); + scrolled.set_vexpand(true); + content.append(&scrolled); let empty = adw::StatusPage::builder() .title(gettext("No Favorites")) + .icon_name("starred-symbolic") .description(gettext("Save a query from the SQL editor to find it here.")) .build(); empty.add_css_class("compact"); let stack = gtk::Stack::new(); - stack.add_named(&scrolled, Some(LIST)); + stack.add_named(&content, Some(LIST)); + stack.add_named(&error, Some("error")); + let loading = adw::StatusPage::builder() + .title(gettext("Loading Favorites")) + .child(&adw::Spinner::new()) + .build(); + loading.add_css_class("compact"); + stack.add_named(&loading, Some("loading")); + let disconnected = adw::StatusPage::builder() + .title(gettext("No Connection Selected")) + .description(gettext("Open a connection to see its saved queries.")) + .icon_name("starred-symbolic") + .build(); + disconnected.add_css_class("compact"); + stack.add_named(&disconnected, Some("disconnected")); stack.add_named(&empty, Some(EMPTY)); stack.set_visible_child_name(EMPTY); - Self { stack, store } + Self { + stack, + store, + selection, + error, + retry: retry_button, + stale, + } } pub(crate) fn widget(&self) -> gtk::Widget { self.stack.clone().upcast() } - /// List `favorites`, the newest save first. - pub(crate) fn show(&self, mut favorites: Vec) { - favorites.sort_by(|a, b| b.updated_at.cmp(&a.updated_at)); + pub(crate) fn clear(&self) { + self.store.remove_all(); + self.stale.set_revealed(false); + } + + pub(crate) fn no_connection(&self) { + self.clear(); + self.stack.set_visible_child_name("disconnected"); + } + + pub(crate) fn loading(&self) { + self.stale.set_revealed(false); + if self.store.n_items() == 0 { + self.stack.set_visible_child_name("loading"); + } + } + + pub(crate) fn unavailable(&self) { + self.clear(); + self.error.set_description(Some(&gettext( + "The query history file could not be opened. Check the file and restart TablePro.", + ))); + self.retry.set_visible(false); + self.stack.set_visible_child_name("error"); + } + + pub(crate) fn failed(&self) { + if self.store.n_items() > 0 { + self.stale.set_revealed(true); + return; + } + self.error + .set_description(Some(&gettext("Saved queries could not be read. Try again."))); + self.retry.set_visible(true); + self.stack.set_visible_child_name("error"); + } + + pub(crate) fn show(&self, favorites: Vec) { + let selected = favorite_at(&self.store, self.selection.selected()).map(|saved| saved.id); + let selected_position = favorites.iter().position(|saved| Some(saved.id) == selected); let items: Vec = favorites.into_iter().map(glib::BoxedAnyObject::new).collect(); self.store.splice(0, self.store.n_items(), &items); + self.selection + .set_selected(selected_position.map_or(gtk::INVALID_LIST_POSITION, |position| position as u32)); + self.stale.set_revealed(false); self.stack .set_visible_child_name(if items.is_empty() { EMPTY } else { LIST }); } @@ -131,3 +214,57 @@ fn factory() -> gtk::SignalListItemFactory { }); factory } + +#[cfg(test)] +mod tests { + use super::*; + use std::time::SystemTime; + use uuid::Uuid; + + fn saved(id: i64, name: &str) -> SavedQuery { + SavedQuery { + id, + name: name.to_owned(), + query: "SELECT 1".to_owned(), + connection_id: Uuid::nil(), + connection_name: "Database".to_owned(), + created_at: SystemTime::UNIX_EPOCH, + updated_at: SystemTime::UNIX_EPOCH, + } + } + + #[gtk4::test] + fn favorites_keep_selection_by_id_after_rename_and_reorder() { + let pane = FavoritesPane::new(|_| {}, || {}); + pane.show(vec![saved(1, "One"), saved(2, "Two")]); + pane.selection.set_selected(1); + pane.show(vec![saved(2, "Renamed"), saved(1, "One")]); + assert_eq!(pane.selection.selected(), 0); + pane.show(vec![saved(1, "One")]); + assert_eq!(pane.selection.selected(), gtk::INVALID_LIST_POSITION); + } + + #[gtk4::test] + fn favorites_distinguish_loading_empty_unavailable_and_failed_refresh() { + let retried = Rc::new(std::cell::Cell::new(false)); + let retry = retried.clone(); + let pane = FavoritesPane::new(|_| {}, move || retry.set(true)); + pane.loading(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("loading")); + pane.failed(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("error")); + pane.retry.emit_clicked(); + assert!(retried.get()); + pane.show(vec![]); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some(EMPTY)); + pane.show(vec![saved(1, "One")]); + pane.failed(); + assert!(pane.stale.is_revealed()); + assert_eq!(pane.names(), ["One"]); + pane.unavailable(); + assert!(!pane.retry.is_visible()); + assert!(pane.names().is_empty()); + pane.no_connection(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("disconnected")); + } +} diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 3f35d692f1..62599522c7 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -72,6 +72,7 @@ impl WorkspaceModel { store: self.history.store().map(|history| history.saved_queries()), active_connection: self.context.active.metadata().map(|metadata| metadata.id), tasks: self.tasks.clone(), + hold: self.context.hold.clone(), }); let input = self.input.clone(); dialog.connect_query_chosen(move |_, destination, text| { @@ -161,13 +162,8 @@ impl WorkspaceModel { return; }; let message = match store.save(new_query).await { - Ok(outcome) => { - input.deliver(WorkspaceInput::SavedQueriesChanged); - match outcome.replaced { - true => crate::i18n::gettext_f("Replaced “{name}”.", &[("name", &name)]), - false => crate::i18n::gettext_f("Saved “{name}”.", &[("name", &name)]), - } - } + Ok(outcome) if outcome.replaced => crate::i18n::gettext_f("Replaced “{name}”.", &[("name", &name)]), + Ok(_) => crate::i18n::gettext_f("Saved “{name}”.", &[("name", &name)]), Err(error) => { tracing::warn!(%error, "could not save the query"); crate::i18n::gettext("Could not save that query.") @@ -229,25 +225,60 @@ mod tests { ); } - /// The Favorites scope lists the front connection's saved queries, and - /// reads them again when one is saved. #[gtk4::test] fn the_favorites_scope_lists_the_saved_queries_of_the_front_connection() { use gtk4::subclass::prelude::ObjectSubclassIsExt; - let test = TestWindow::connected("FavoritesScope"); let history = test.services.history(); let availability = history.availability(); - wait_until(WAIT, || availability.borrow().is_ready()).expect("the query database to open"); - let shell = test.window.shell().expect("the shell"); - let favorites = shell.imp().favorites.get().cloned().expect("the favorites pane"); - + wait_until(WAIT, || availability.borrow().is_ready()).expect("history ready"); + let shell = test.window.shell().expect("shell"); + let favorites = shell.imp().favorites.get().expect("favorites"); shell.imp().scope_toggle.set_active_name(Some("favorites")); - assert!(favorites.names().is_empty(), "nothing is saved yet"); - test.workspace() .with_model(|model| model.on_save_query_named("Orders".to_owned(), "SELECT 1".to_owned())); - wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); + wait_until(WAIT, || favorites.names() == ["Orders"]).expect("saved query listed"); + let store = history.store().expect("history").saved_queries(); + let work = test.services.tasks.spawn_task(async move { + let saved = store.list(None).await.expect("list"); + store.rename(saved[0].id, "Renamed").await.expect("rename"); + }); + finish_on_main(WAIT, work).expect("rename finished").expect("task"); + wait_until(WAIT, || favorites.names() == ["Renamed"]).expect("external rename listed"); + let store = history.store().expect("history").saved_queries(); + let work = test.services.tasks.spawn_task(async move { + let saved = store.list(None).await.expect("list"); + store.delete(saved[0].id).await.expect("delete"); + }); + finish_on_main(WAIT, work).expect("delete finished").expect("task"); + wait_until(WAIT, || favorites.names().is_empty()).expect("external deletion listed"); + } + + #[gtk4::test] + fn favorites_for_an_unsaved_file_survive_reopening_it() { + use gtk4::{gio, subclass::prelude::ObjectSubclassIsExt}; + let test = TestWindow::picker("FileFavorites"); + let root = tempfile::tempdir().expect("tempdir"); + let path = root.path().join("favorites.db"); + std::fs::write(&path, "").expect("database"); + let file = gio::File::for_path(path); + test.window.send(crate::ui::SessionWindowInput::OpenFile(file.clone())); + test.wait_for_page("workspace"); + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("history ready"); + let connection = test.workspace().connection_id(); + test.workspace() + .with_model(|model| model.on_save_query_named("File query".to_owned(), "SELECT 2".to_owned())); + wait_until(WAIT, || test.hold.live() == 0).expect("save finished"); + test.window.send(crate::ui::SessionWindowInput::Disconnect); + test.wait_for_page("picker"); + test.window.send(crate::ui::SessionWindowInput::OpenFile(file)); + test.wait_for_page("workspace"); + assert_eq!(test.workspace().connection_id(), connection); + let shell = test.window.shell().expect("shell"); + shell.imp().scope_toggle.set_active_name(Some("favorites")); + let favorites = shell.imp().favorites.get().expect("favorites"); + wait_until(WAIT, || favorites.names() == ["File query"]).expect("file query listed after reopen"); } #[gtk4::test] diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 35188fda76..27caaaa75a 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -11,7 +11,6 @@ use gtk4::subclass::prelude::*; use libadwaita as adw; use libadwaita::prelude::BinExt; use tablepro_core::DataModel; -use tablepro_session::SessionKey; use uuid::Uuid; use super::health_banner::REVIEW_HOST_KEY; @@ -36,6 +35,11 @@ const FAVORITES: &str = "favorites"; /// The window action that shows and hides the assistant's column. pub(super) const SHOW_ASSISTANT: &str = "show-assistant"; +type FavoritesRead = Result< + Option, tablepro_storage::StorageError>>, + tablepro_session::runtime::TaskFailure, +>; + glib::wrapper! { pub struct WorkspaceShell(ObjectSubclass) @extends adw::Bin, gtk::Widget, @@ -93,16 +97,35 @@ impl WorkspaceShell { let tree = ConnectionTree::new(services.saved_connections.clone()); let sidebar = gtk::Stack::new(); sidebar.add_named(&tree.widget(), Some(TABLES)); - let favorites = super::sidebar::FavoritesPane::new(glib::clone!( - #[weak] - shell, - move |sql| shell.open_favorite(sql) - )); + let favorites = super::sidebar::FavoritesPane::new( + glib::clone!( + #[weak] + shell, + move |sql| shell.open_favorite(sql) + ), + glib::clone!( + #[weak] + shell, + move || shell.reload_favorites() + ), + ); sidebar.add_named(&favorites.widget(), Some(FAVORITES)); imp.sidebar_slot.set_child(Some(&sidebar)); let _ = imp.sidebar_stack.set(sidebar); let _ = imp.favorites.set(favorites); let _ = imp.favorites_source.set((services.history(), services.tasks.clone())); + imp.favorites_availability + .replace(Some(tablepro_session::runtime::WatchForwarder::new( + services.history().availability(), + glib::clone!( + #[weak] + shell, + move |_| shell.follow_favorites() + ), + |future| { + glib::spawn_future_local(future); + }, + ))); imp.scope_toggle.connect_active_name_notify(glib::clone!( #[weak] shell, @@ -553,9 +576,6 @@ impl WorkspaceShell { self.notify_front(); } - /// Show the front's banners and assistant, and name what follows its - /// data model after it. The expressions of `bind_front` do the rest. - /// The sidebar shows its tables or its favorites. fn on_scope_changed(&self) { let imp = self.imp(); let favorites = imp.scope_toggle.active_name().as_deref() == Some(FAVORITES); @@ -564,42 +584,93 @@ impl WorkspaceShell { } // The search reads connections and tables, which this scope does not list. imp.table_search_toggle.set_visible(!favorites); + imp.refresh_tables_button.set_visible(!favorites); + if favorites { + imp.table_search_bar.set_search_mode(false); + imp.table_search_bar.set_key_capture_widget(None::<>k::Widget>); + } else { + imp.table_search_bar.set_key_capture_widget(Some(&*imp.sidebar_root)); + } + self.reload_favorites(); + } + + fn follow_favorites(&self) { + let imp = self.imp(); + if imp.favorites_watch.borrow().is_none() + && let Some((history, _)) = imp.favorites_source.get() + && let Some(history) = history.store() + { + imp.favorites_watch + .replace(Some(tablepro_session::runtime::WatchForwarder::new( + history.saved_queries().changes(), + glib::clone!( + #[weak(rename_to = shell)] + self, + move |_| shell.reload_favorites() + ), + |future| { + glib::spawn_future_local(future); + }, + ))); + } self.reload_favorites(); } - /// Read the front session's favorites again, while they are shown. pub(crate) fn reload_favorites(&self) { let imp = self.imp(); - if imp.scope_toggle.active_name().as_deref() != Some(FAVORITES) { + let generation = imp.favorites_generation.get().wrapping_add(1); + imp.favorites_generation.set(generation); + let connection = self.front().and_then(|front| front.connection_id()); + let (Some(pane), Some((history, tasks))) = (imp.favorites.get(), imp.favorites_source.get()) else { return; + }; + if imp.favorites_connection.replace(connection) != connection { + pane.clear(); } - let (Some(pane), Some((history, tasks))) = (imp.favorites.get().cloned(), imp.favorites_source.get()) else { + if imp.scope_toggle.active_name().as_deref() != Some(FAVORITES) { return; - }; - let connection = self.front().and_then(|front| front.key()).and_then(|key| match key { - SessionKey::Saved(id) | SessionKey::SavedIn { id, .. } => Some(id), - SessionKey::File(_) => None, - }); + } let Some(connection) = connection else { - pane.show(Vec::new()); + pane.no_connection(); return; }; + pane.loading(); let ready = history.ready_store(); crate::runtime::spawn_and_deliver( tasks, async move { - let store = ready.await?.saved_queries(); - store.list(Some(connection)).await.ok() - }, - move |listed| { - if let Ok(Some(favorites)) = listed { - pane.show(favorites); - } + let Some(history) = ready.await else { + return None; + }; + Some(history.saved_queries().list(Some(connection)).await) }, + glib::clone!( + #[weak(rename_to = shell)] + self, + move |listed| shell.favorites_arrived(generation, connection, listed) + ), ); } - /// A favorite was picked: its SQL opens in a new query tab of the front session. + fn favorites_arrived(&self, generation: u64, connection: Uuid, listed: FavoritesRead) { + if self.imp().favorites_generation.get() != generation + || self.front().and_then(|front| front.connection_id()) != Some(connection) + { + return; + } + let Some(pane) = self.imp().favorites.get() else { + return; + }; + match listed { + Ok(Some(Ok(favorites))) => pane.show(favorites), + Ok(None) => pane.unavailable(), + other => { + tracing::warn!(?other, "could not read favorites"); + pane.failed(); + } + } + } + fn open_favorite(&self, sql: String) { if let Some(sender) = self.front().and_then(|front| front.sender()) { sender.deliver(super::WorkspaceInput::OpenHistoryQuery(sql)); @@ -750,6 +821,10 @@ impl WorkspaceShell { /// names itself again from here on. pub(crate) fn shutdown(&self) { let imp = self.imp(); + imp.favorites_generation + .set(imp.favorites_generation.get().wrapping_add(1)); + imp.favorites_watch.take(); + imp.favorites_availability.take(); for watch in imp.watches.take() { watch.unwatch(); } @@ -878,6 +953,38 @@ mod tests { use crate::config::RESOURCE_BASE_PATH; use crate::test_support::assert_access_keys; + #[gtk4::test] + fn favorites_reject_old_reads_and_clear_rows_when_the_front_changes() { + use crate::ui::session_window::tests::TestWindow; + use tablepro_storage::saved_queries::SavedQuery; + let test = TestWindow::connected("FavoritesRequests"); + let shell = test.window.shell().expect("shell"); + shell.imp().scope_toggle.set_active_name(Some(FAVORITES)); + let connection = test.workspace().connection_id().expect("connection"); + let old = shell.imp().favorites_generation.get(); + shell.reload_favorites(); + let current = shell.imp().favorites_generation.get(); + let saved = SavedQuery { + id: 1, + name: "Current".to_owned(), + query: "SELECT 1".to_owned(), + connection_id: connection, + connection_name: "Database".to_owned(), + created_at: std::time::SystemTime::UNIX_EPOCH, + updated_at: std::time::SystemTime::UNIX_EPOCH, + }; + shell.favorites_arrived(current, connection, Ok(Some(Ok(vec![saved.clone()])))); + let pane = shell.imp().favorites.get().expect("pane"); + shell.favorites_arrived(old, connection, Ok(Some(Ok(vec![])))); + assert_eq!(pane.names(), ["Current"]); + shell.favorites_arrived(current, Uuid::new_v4(), Ok(Some(Ok(vec![])))); + assert_eq!(pane.names(), ["Current"]); + shell.set_front(None); + assert!(pane.names().is_empty()); + shell.favorites_arrived(current, connection, Ok(Some(Ok(vec![saved])))); + assert!(pane.names().is_empty()); + } + #[gtk4::test] fn the_tab_menu_and_the_main_menu_give_each_item_its_own_access_key() { crate::register_test_resources(); diff --git a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs index 9ddd146323..95f0794760 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs @@ -124,6 +124,10 @@ pub struct WorkspaceShell { crate::services::history_service::HistoryService, tablepro_session::runtime::Tasks, )>, + pub(super) favorites_generation: Cell, + pub(super) favorites_connection: Cell>, + pub(super) favorites_watch: RefCell>, + pub(super) favorites_availability: RefCell>, /// The window the shell added its actions to. pub(super) window: glib::WeakRef, pub(super) sender: OnceCell>, diff --git a/linux/docs/storage.md b/linux/docs/storage.md index d21106bf82..c0e15b45b0 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -266,6 +266,26 @@ can tell whether a re-pinned entry falls in the pages already read. - `connections_with_history` lists each connection the history holds under the name of its latest run, so a renamed connection shows once. +### Following the saved queries + +`SavedQueries::changes` is a watch of a revision that every handle of one +database shares. A save, a save of a new name, a rename, a delete and a +connection's queries going move it on once they landed; a read, and a write +that changed nothing, leave it. The sidebar's Favorites and the Saved Queries +dialog read again on each revision, so a write from any window, an import or +a deleted connection reaches every list. Each list rejects replies from an +older read and keeps selection by saved-query id. Confirmed saves, renames +and deletions hold the process until the write finishes. + +Saving under an existing name updates the same row id. The existence check +and write share a transaction, so simultaneous saves report which one +replaced the query. Renames update only the stored name and modification +time, leaving newer SQL and the connection identity intact. + +Unsaved database files use a UUID derived from their canonical URI, so queries +stay in the same scope after reopening the file. Queries saved by older builds +with a temporary file identity remain available in the Saved Queries dialog. + ### What goes into the history `HistoryService::record` is the one way in, for editor runs, saves and diff --git a/linux/po/POTFILES.in b/linux/po/POTFILES.in index 23a2291ef9..3f0065ec44 100644 --- a/linux/po/POTFILES.in +++ b/linux/po/POTFILES.in @@ -621,6 +621,7 @@ crates/app/src/ui/workspace/saves.rs crates/app/src/ui/workspace/session_watches.rs crates/app/src/ui/workspace/sidebar/catalog_watch.rs crates/app/src/ui/workspace/sidebar/connection_tree.rs +crates/app/src/ui/workspace/sidebar/favorites_pane.rs crates/app/src/ui/workspace/sidebar/key_listing.rs crates/app/src/ui/workspace/sidebar/mod.rs crates/app/src/ui/workspace/sidebar/object_key.rs From 5eaa8712bf93b954a03e49635d58329ba51ba6f1 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 20:02:13 +0700 Subject: [PATCH 10/23] fix(linux-sidebar): confirm saved query replacement --- core/crates/storage/src/saved_queries/mod.rs | 17 ++++ linux/crates/app/src/ui/workspace/imp.rs | 2 +- linux/crates/app/src/ui/workspace/mod.rs | 4 + .../app/src/ui/workspace/status_pages.rs | 82 ++++++++++++++++++- .../app/src/ui/workspace/workspace_shell.rs | 5 +- .../src/ui/workspace/workspace_shell_imp.rs | 2 - linux/data/resources/ui/workspace-shell.ui | 2 - linux/docs/storage.md | 3 +- 8 files changed, 103 insertions(+), 14 deletions(-) diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index f2dd7a7899..88dedfd222 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -352,6 +352,23 @@ mod tests { assert_eq!(all[0].query, "SELECT 2"); } + #[tokio::test] + async fn concurrent_new_saves_never_overwrite_the_winner() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + let (first, second) = tokio::join!( + store.save_if_new(new_query("daily", "SELECT 1", connection)), + store.save_if_new(new_query("daily", "SELECT 2", connection)), + ); + let first = first.expect("first save"); + let second = second.expect("second save"); + assert_ne!(first.is_some(), second.is_some()); + let saved = store.list(Some(connection)).await.expect("list"); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].query, if first.is_some() { "SELECT 1" } else { "SELECT 2" }); + } + #[tokio::test] async fn concurrent_saves_report_exactly_one_replacement_and_keep_the_id() { let root = tempfile::tempdir().expect("tempdir"); diff --git a/linux/crates/app/src/ui/workspace/imp.rs b/linux/crates/app/src/ui/workspace/imp.rs index 8a267028de..02cc65ce56 100644 --- a/linux/crates/app/src/ui/workspace/imp.rs +++ b/linux/crates/app/src/ui/workspace/imp.rs @@ -56,7 +56,7 @@ pub struct Workspace { pub(super) assistant_available: Cell, pub(super) key: OnceCell, - // The connection id its saved queries are kept under, which the editor's Save Query writes with. + // File sessions and saved connections must use the editor save's identity. pub(super) connection_id: OnceCell, pub(super) data_model: OnceCell, /// Which tab each of the session's pages shows, shared with the diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 44d49513ab..9afe573224 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -546,6 +546,8 @@ pub(crate) enum WorkspaceInput { ShowHistory, ShowSavedQueries, ActiveTab(workspace_tabs::ActiveTabCommand), + ConfirmReplaceSavedQuery(tablepro_storage::saved_queries::NewSavedQuery), + ReplaceSavedQuery(tablepro_storage::saved_queries::NewSavedQuery), SaveQueryNamed { name: String, query: String, @@ -1411,6 +1413,8 @@ impl WorkspaceModel { WorkspaceInput::ImportCsvRun(import) => self.on_import_csv_run(*import), WorkspaceInput::ActiveTab(command) => self.on_active_tab_command(command), WorkspaceInput::SaveQueryNamed { name, query } => self.on_save_query_named(name, query), + WorkspaceInput::ConfirmReplaceSavedQuery(query) => self.confirm_replace_saved_query(query), + WorkspaceInput::ReplaceSavedQuery(query) => self.save_named_query(query, true), WorkspaceInput::OpenHistoryQuery(text) => self.open_editor_tab(Some(text)), WorkspaceInput::ReplaceActiveTabQuery(text) => self.on_replace_active_tab_query(text), WorkspaceInput::RefreshPage => self.on_refresh_active_tab(), diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 62599522c7..86cc7fc4d5 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -143,11 +143,40 @@ impl WorkspaceModel { return; }; let new_query = tablepro_storage::saved_queries::NewSavedQuery { - name: name.clone(), + name, query, connection_id: metadata.id, connection_name: metadata.name, }; + self.save_named_query(new_query, false); + } + + pub(super) fn confirm_replace_saved_query(&self, query: tablepro_storage::saved_queries::NewSavedQuery) { + let dialog = adw::AlertDialog::new( + Some(&crate::i18n::gettext_f( + "Replace “{name}”?", + &[("name", query.name.trim())], + )), + Some(&crate::i18n::gettext( + "A saved query already uses this name. Replacing it will overwrite its SQL.", + )), + ); + dialog.add_response("cancel", &crate::i18n::gettext("Cancel")); + dialog.add_response("replace", &crate::i18n::gettext("Replace")); + dialog.set_response_appearance("replace", adw::ResponseAppearance::Destructive); + dialog.set_default_response(Some("cancel")); + dialog.set_close_response("cancel"); + let input = self.input.clone(); + dialog.connect_response(None, move |_, response| { + if response == "replace" { + input.deliver(WorkspaceInput::ReplaceSavedQuery(query.clone())); + } + }); + dialog.present(self.dialog_parent().as_ref()); + } + + pub(super) fn save_named_query(&self, new_query: tablepro_storage::saved_queries::NewSavedQuery, replace: bool) { + let name = new_query.name.clone(); // The save lands even when the workspace is gone by then; only // its toast is dropped. A database still opening is waited for. let input = self.input.clone(); @@ -161,9 +190,21 @@ impl WorkspaceModel { }); return; }; - let message = match store.save(new_query).await { - Ok(outcome) if outcome.replaced => crate::i18n::gettext_f("Replaced “{name}”.", &[("name", &name)]), - Ok(_) => crate::i18n::gettext_f("Saved “{name}”.", &[("name", &name)]), + let saved = if replace { + store.save(new_query).await.map(|outcome| outcome.replaced) + } else { + match store.save_if_new(new_query.clone()).await { + Ok(Some(_)) => Ok(false), + Ok(None) => { + input.deliver(WorkspaceInput::ConfirmReplaceSavedQuery(new_query)); + return; + } + Err(error) => Err(error), + } + }; + let message = match saved { + Ok(true) => crate::i18n::gettext_f("Replaced “{name}”.", &[("name", &name)]), + Ok(false) => crate::i18n::gettext_f("Saved “{name}”.", &[("name", &name)]), Err(error) => { tracing::warn!(%error, "could not save the query"); crate::i18n::gettext("Could not save that query.") @@ -225,6 +266,39 @@ mod tests { ); } + #[gtk4::test] + fn replacing_a_saved_query_needs_confirmation_and_keeps_its_id() { + use crate::workspace::{answer, visible_alert}; + let test = TestWindow::connected("ConfirmSavedQuery"); + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("history ready"); + let save = |sql: &str| { + test.workspace() + .with_model(|model| model.on_save_query_named("Orders".to_owned(), sql.to_owned())); + wait_until(WAIT, || test.hold.live() == 0).expect("save complete"); + }; + let read = || { + let store = test.services.history().store().expect("history").saved_queries(); + let reading = test.services.tasks.spawn_task(async move { store.list(None).await }); + finish_on_main(WAIT, reading) + .expect("read complete") + .expect("task") + .expect("list") + .remove(0) + }; + save("SELECT 1"); + let original = read(); + save("SELECT 2"); + wait_until(WAIT, || visible_alert(&test.window).is_some()).expect("replace prompt"); + answer(&test.window, "cancel"); + assert_eq!(read().query, "SELECT 1"); + save("SELECT 3"); + wait_until(WAIT, || visible_alert(&test.window).is_some()).expect("replace prompt"); + answer(&test.window, "replace"); + wait_until(WAIT, || read().query == "SELECT 3").expect("replacement"); + assert_eq!(read().id, original.id); + } + #[gtk4::test] fn the_favorites_scope_lists_the_saved_queries_of_the_front_connection() { use gtk4::subclass::prelude::ObjectSubclassIsExt; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 27caaaa75a..6fe5251925 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -28,7 +28,6 @@ use crate::ui::shell::{PRIMARY_MENU, TAB_OVERVIEW_MENU, app_menu, primary_menu_b /// names it. pub(super) const SHOW_SIDEBAR: &str = "show-sidebar"; -/// The sidebar's two lists, which its scope switch names. const TABLES: &str = "tables"; const FAVORITES: &str = "favorites"; @@ -639,9 +638,7 @@ impl WorkspaceShell { crate::runtime::spawn_and_deliver( tasks, async move { - let Some(history) = ready.await else { - return None; - }; + let history = ready.await?; Some(history.saved_queries().list(Some(connection)).await) }, glib::clone!( diff --git a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs index 95f0794760..f9bcdaad90 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs @@ -116,10 +116,8 @@ pub struct WorkspaceShell { /// The saved connections, and the schemas and tables of each one open /// in the window. pub(super) tree: OnceCell, - /// The sidebar's lists: the tree, and the favorites of the front session. pub(super) sidebar_stack: OnceCell, pub(super) favorites: OnceCell, - /// Where the favorites are read from, and the runtime that reads them. pub(super) favorites_source: OnceCell<( crate::services::history_service::HistoryService, tablepro_session::runtime::Tasks, diff --git a/linux/data/resources/ui/workspace-shell.ui b/linux/data/resources/ui/workspace-shell.ui index 7c4f3b5235..6f5948ee43 100644 --- a/linux/data/resources/ui/workspace-shell.ui +++ b/linux/data/resources/ui/workspace-shell.ui @@ -86,8 +86,6 @@ - tables true diff --git a/linux/docs/storage.md b/linux/docs/storage.md index c0e15b45b0..3c9ab1f113 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -277,7 +277,8 @@ a deleted connection reaches every list. Each list rejects replies from an older read and keeps selection by saved-query id. Confirmed saves, renames and deletions hold the process until the write finishes. -Saving under an existing name updates the same row id. The existence check +The editor first inserts without replacement and asks for confirmation if the +name is taken. Confirmed replacement updates the same row id. The existence check and write share a transaction, so simultaneous saves report which one replaced the query. Renames update only the stored name and modification time, leaving newer SQL and the connection identity intact. From eccf8c7983bc5b970f9bbabada3787831c23e74a Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:29:19 +0100 Subject: [PATCH 11/23] feat(linux-sidebar): file favorites in folders --- .../ui/workspace/sidebar/favorites_pane.rs | 383 +++++++++++++----- .../app/src/ui/workspace/status_pages.rs | 28 ++ .../app/src/ui/workspace/workspace_shell.rs | 195 ++++++++- 3 files changed, 489 insertions(+), 117 deletions(-) diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 96f617ce68..94c320d071 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -1,65 +1,161 @@ //! The sidebar's Favorites scope: the named queries the user kept for the -//! connection in front, as the macOS sidebar lists them beside its -//! tables. Activating one opens it in a new query tab. +//! connection in front, filed in folders that nest, as the macOS sidebar +//! lists them beside its tables. Activating a query opens it in a new +//! query tab; a folder opens and closes. +use std::cell::RefCell; +use std::collections::HashMap; use std::rc::Rc; use gtk4 as gtk; use gtk4::prelude::*; use gtk4::{gio, glib}; use libadwaita as adw; -use tablepro_storage::saved_queries::SavedQuery; +use tablepro_storage::saved_queries::{SavedQuery, SavedQueryFolder}; use crate::i18n::gettext; const LIST: &str = "list"; const EMPTY: &str = "empty"; -/// What the user asks of a favorite. +/// What the user asks of a favorite or a folder. #[derive(Debug, Clone)] pub(crate) enum FavoriteAction { /// Open its SQL in a new query tab. Open(String), Rename(SavedQuery), Delete(SavedQuery), + /// File the query in another folder, or at the top. + MoveTo(SavedQuery), + /// Make a folder inside `parent`, none for the top. + NewFolder(Option), + RenameFolder(SavedQueryFolder), + DeleteFolder(SavedQueryFolder), } type Asked = Rc; -/// The class that marks a favorite's row, which carries its id as its name. +/// What a row of the tree holds. +#[derive(Debug, Clone)] +enum Node { + Folder(SavedQueryFolder), + Query(SavedQuery), +} + +impl Node { + /// The id its row carries as its name: `f` or `q`, then the id. + fn key(&self) -> String { + match self { + Node::Folder(folder) => format!("f{}", folder.id), + Node::Query(query) => format!("q{}", query.id), + } + } +} + +/// The nodes by the folder that holds them, subfolders first, then queries. +#[derive(Default)] +struct Index { + children: HashMap, Vec>, + by_key: HashMap, +} + +impl Index { + fn of(mut queries: Vec, folders: Vec) -> Self { + queries.sort_by(|a, b| { + a.order + .cmp(&b.order) + .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())) + }); + let mut index = Index::default(); + for folder in folders { + let node = Node::Folder(folder.clone()); + index.by_key.insert(node.key(), node.clone()); + index.children.entry(folder.parent_id).or_default().push(node); + } + for query in queries { + let node = Node::Query(query.clone()); + index.by_key.insert(node.key(), node.clone()); + index.children.entry(query.folder_id).or_default().push(node); + } + index + } + + fn model_of(&self, parent: Option) -> gio::ListStore { + let store = gio::ListStore::new::(); + for node in self.children.get(&parent).into_iter().flatten() { + store.append(&glib::BoxedAnyObject::new(node.clone())); + } + store + } + + #[cfg(test)] + fn queries(&self) -> Vec { + self.by_key + .values() + .filter_map(|node| match node { + Node::Query(query) => Some(query.clone()), + Node::Folder(_) => None, + }) + .collect() + } +} + const ROW: &str = "favorite-row"; const RENAME: &str = "rename"; const DELETE: &str = "delete"; +const MOVE: &str = "move"; +const NEW_FOLDER: &str = "new-folder"; #[derive(Clone)] pub(crate) struct FavoritesPane { + whole: gtk::Box, stack: gtk::Stack, - store: gio::ListStore, + root: gio::ListStore, + index: Rc>>, } impl FavoritesPane { pub(crate) fn new(asked: impl Fn(FavoriteAction) + 'static) -> Self { - let store = gio::ListStore::new::(); + let asked: Asked = Rc::new(asked); + let root = gio::ListStore::new::(); + let index: Rc>> = Rc::default(); + let tree = gtk::TreeListModel::new(root.clone(), false, true, { + let index = index.clone(); + move |item| { + let node = item.downcast_ref::()?.borrow::().clone(); + match node { + Node::Folder(folder) => Some(index.borrow().model_of(Some(folder.id)).upcast()), + Node::Query(_) => None, + } + } + }); let selection = gtk::SingleSelection::builder() - .model(&store) + .model(&tree) .autoselect(false) .can_unselect(true) .build(); - let list = gtk::ListView::new(Some(selection), Some(factory())); + let list = gtk::ListView::new(Some(selection.clone()), Some(factory())); list.add_css_class("navigation-sidebar"); list.set_single_click_activate(true); list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); - let asked: Asked = Rc::new(asked); - let model = store.clone(); - let open = asked.clone(); - list.connect_activate(move |_, position| { - if let Some(favorite) = favorite_at(&model, position) { - open(FavoriteAction::Open(favorite.query)); + list.connect_activate({ + let (selection, asked) = (selection.clone(), asked.clone()); + move |_, position| { + let Some(row) = selection.item(position).and_downcast::() else { + return; + }; + match node_of(&row) { + Some(Node::Query(query)) => asked(FavoriteAction::Open(query.query)), + Some(Node::Folder(_)) => row.set_expanded(!row.is_expanded()), + None => {} + } } }); - install_menu(&list, &store, &selection_of(&list), &asked); + install_menu(&list, &selection, &index, &asked); + let scrolled = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) + .vexpand(true) .child(&list) .build(); let empty = adw::StatusPage::builder() @@ -71,67 +167,114 @@ impl FavoritesPane { stack.add_named(&scrolled, Some(LIST)); stack.add_named(&empty, Some(EMPTY)); stack.set_visible_child_name(EMPTY); - Self { stack, store } + stack.set_vexpand(true); + + let new_folder = gtk::Button::builder() + .label(gettext("New Folder")) + .icon_name("folder-new-symbolic") + .halign(gtk::Align::Start) + .margin_top(6) + .margin_bottom(6) + .margin_start(6) + .build(); + new_folder.add_css_class("flat"); + new_folder.connect_clicked({ + let asked = asked.clone(); + move |_| asked(FavoriteAction::NewFolder(None)) + }); + let whole = gtk::Box::new(gtk::Orientation::Vertical, 0); + whole.append(&stack); + whole.append(&new_folder); + Self { + whole, + stack, + root, + index, + } } pub(crate) fn widget(&self) -> gtk::Widget { - self.stack.clone().upcast() + self.whole.clone().upcast() + } + + /// List `queries` in `folders`. + pub(crate) fn show(&self, queries: Vec, folders: Vec) { + let empty = queries.is_empty() && folders.is_empty(); + let index = Rc::new(Index::of(queries, folders)); + self.index.replace(index.clone()); + let top = index.model_of(None); + let items: Vec = (0..top.n_items()).filter_map(|position| top.item(position)).collect(); + self.root.splice(0, self.root.n_items(), &items); + self.stack.set_visible_child_name(if empty { EMPTY } else { LIST }); } - /// List `favorites`, the newest save first. - pub(crate) fn show(&self, mut favorites: Vec) { - favorites.sort_by(|a, b| b.updated_at.cmp(&a.updated_at)); - let items: Vec = favorites.into_iter().map(glib::BoxedAnyObject::new).collect(); - self.store.splice(0, self.store.n_items(), &items); - self.stack - .set_visible_child_name(if items.is_empty() { EMPTY } else { LIST }); + /// The folders as they are listed, for a dialog that picks one. + pub(crate) fn folders(&self) -> Vec { + self.index + .borrow() + .by_key + .values() + .filter_map(|node| match node { + Node::Folder(folder) => Some(folder.clone()), + Node::Query(_) => None, + }) + .collect() } #[cfg(test)] pub(crate) fn ids(&self) -> Vec { - (0..self.store.n_items()) - .filter_map(|position| favorite_at(&self.store, position)) - .map(|favorite| favorite.id) - .collect() + let mut ids: Vec = self.index.borrow().queries().iter().map(|query| query.id).collect(); + ids.sort_unstable(); + ids + } + + #[cfg(test)] + pub(crate) fn folder_of_first_query(&self) -> Option { + self.index.borrow().queries().first().and_then(|query| query.folder_id) } #[cfg(test)] pub(crate) fn names(&self) -> Vec { - (0..self.store.n_items()) - .filter_map(|position| favorite_at(&self.store, position)) - .map(|favorite| favorite.name) - .collect() + let mut queries = self.index.borrow().queries(); + queries.sort_by_key(|query| (query.updated_at, query.id)); + queries.sort_by(|a, b| b.updated_at.cmp(&a.updated_at)); + queries.into_iter().map(|query| query.name).collect() } } -fn selection_of(list: >k::ListView) -> gtk::SingleSelection { - list.model() - .and_downcast::() - .unwrap_or_else(|| gtk::SingleSelection::new(None::)) +fn node_of(row: >k::TreeListRow) -> Option { + Some( + row.item() + .and_downcast::()? + .borrow::() + .clone(), + ) } -/// Rename and Delete, from a right click on a row or F2 and Delete on the -/// selected one. The menu names the row by its id, which no reload moves. -fn install_menu(list: >k::ListView, store: &gio::ListStore, selection: >k::SingleSelection, asked: &Asked) { - let find = { - let store = store.clone(); - move |id: i64| { - (0..store.n_items()) - .filter_map(|position| favorite_at(&store, position)) - .find(|favorite| favorite.id == id) - } - }; +/// Rename, Move to Folder, New Subfolder and Delete, from a right click on +/// a row or F2 and Delete on the selected one. The menu names the row by +/// its key, which no reload moves. +fn install_menu(list: >k::ListView, selection: >k::SingleSelection, index: &Rc>>, asked: &Asked) { let actions = gio::SimpleActionGroup::new(); - for (name, make) in [ - (RENAME, FavoriteAction::Rename as fn(SavedQuery) -> FavoriteAction), - (DELETE, FavoriteAction::Delete), - ] { - let action = gio::SimpleAction::new(name, Some(glib::VariantTy::INT64)); - let (find, asked) = (find.clone(), asked.clone()); - action.connect_activate(move |_, id| { - if let Some(favorite) = id.and_then(|id| id.get::()).and_then(&find) { - asked(make(favorite)); - } + for name in [RENAME, DELETE, MOVE, NEW_FOLDER] { + let action = gio::SimpleAction::new(name, Some(glib::VariantTy::STRING)); + let (index, asked) = (index.clone(), asked.clone()); + action.connect_activate(move |_, key| { + let Some(node) = key + .and_then(|key| key.str()) + .and_then(|key| index.borrow().by_key.get(key).cloned()) + else { + return; + }; + asked(match (name, node) { + (RENAME, Node::Query(query)) => FavoriteAction::Rename(query), + (RENAME, Node::Folder(folder)) => FavoriteAction::RenameFolder(folder), + (DELETE, Node::Query(query)) => FavoriteAction::Delete(query), + (DELETE, Node::Folder(folder)) => FavoriteAction::DeleteFolder(folder), + (MOVE, Node::Query(query)) => FavoriteAction::MoveTo(query), + (_, Node::Folder(folder)) => FavoriteAction::NewFolder(Some(folder)), + (_, Node::Query(query)) => FavoriteAction::Open(query.query), + }); }); actions.add_action(&action); } @@ -142,16 +285,16 @@ fn install_menu(list: >k::ListView, store: &gio::ListStore, selection: >k::S popover.set_parent(list); let click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_SECONDARY).build(); { - let (list, store, popover) = (list.downgrade(), store.clone(), popover.clone()); + let (list, index, popover) = (list.downgrade(), index.clone(), popover.clone()); click.connect_pressed(move |gesture, _, x, y| { let Some(list) = list.upgrade() else { return; }; - let Some(favorite) = row_at(&list, &store, x, y) else { + let Some(node) = row_at(&list, &index, x, y) else { return; }; gesture.set_state(gtk::EventSequenceState::Claimed); - popover.set_menu_model(Some(&menu_of(favorite.id))); + popover.set_menu_model(Some(&menu_of(&node))); popover.set_pointing_to(Some(>k::gdk::Rectangle::new(x as i32, y as i32, 1, 1))); popover.popup(); }); @@ -161,59 +304,76 @@ fn install_menu(list: >k::ListView, store: &gio::ListStore, selection: >k::S list.connect_destroy(move |_| popover.unparent()); let keys = gtk::EventControllerKey::new(); - let (selection, store, asked) = (selection.clone(), store.clone(), asked.clone()); + let (selection, asked) = (selection.clone(), asked.clone()); keys.connect_key_pressed(move |_, key, _, _| { - let Some(favorite) = favorite_at(&store, selection.selected()) else { + let Some(node) = selection + .selected_item() + .and_downcast::() + .as_ref() + .and_then(node_of) + else { return glib::Propagation::Proceed; }; - match key { - gtk::gdk::Key::F2 => asked(FavoriteAction::Rename(favorite)), - gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete => asked(FavoriteAction::Delete(favorite)), + let action = match (key, node) { + (gtk::gdk::Key::F2, Node::Query(query)) => FavoriteAction::Rename(query), + (gtk::gdk::Key::F2, Node::Folder(folder)) => FavoriteAction::RenameFolder(folder), + (gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete, Node::Query(query)) => FavoriteAction::Delete(query), + (gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete, Node::Folder(folder)) => { + FavoriteAction::DeleteFolder(folder) + } _ => return glib::Propagation::Proceed, - } + }; + asked(action); glib::Propagation::Stop }); list.add_controller(keys); } -fn menu_of(id: i64) -> gio::Menu { +fn menu_of(node: &Node) -> gio::Menu { + let key = node.key(); + let entries: Vec<(String, &str)> = match node { + Node::Query(_) => vec![ + (gettext("_Rename…"), RENAME), + (gettext("_Move to Folder…"), MOVE), + (gettext("_Delete…"), DELETE), + ], + Node::Folder(_) => vec![ + (gettext("New _Subfolder…"), NEW_FOLDER), + (gettext("_Rename…"), RENAME), + (gettext("_Delete…"), DELETE), + ], + }; let menu = gio::Menu::new(); - for (label, action) in [(gettext("_Rename…"), RENAME), (gettext("_Delete…"), DELETE)] { + for (label, action) in entries { let item = gio::MenuItem::new(Some(&label), None); - item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&id.to_variant())); + item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&key.to_variant())); menu.append_item(&item); } menu } -/// The favorite drawn at `(x, y)` in the list. Each row is named by its -/// favorite's id as it binds, so a row finds its favorite however the -/// list has scrolled and recycled. -fn row_at(list: >k::ListView, store: &gio::ListStore, x: f64, y: f64) -> Option { +/// The node drawn at `(x, y)`. Each row is named by its key as it binds, so +/// a row finds its node however the list has scrolled and recycled. +fn row_at(list: >k::ListView, index: &Rc>>, x: f64, y: f64) -> Option { let mut widget = list.pick(x, y, gtk::PickFlags::DEFAULT); while let Some(candidate) = widget { if candidate.has_css_class(ROW) { - let id: i64 = candidate.widget_name().parse().ok()?; - return (0..store.n_items()) - .filter_map(|position| favorite_at(store, position)) - .find(|favorite| favorite.id == id); + return index.borrow().by_key.get(candidate.widget_name().as_str()).cloned(); } widget = candidate.parent(); } None } -fn favorite_at(store: &gio::ListStore, position: u32) -> Option { - let item = store.item(position).and_downcast::()?; - Some(item.borrow::().clone()) -} - fn factory() -> gtk::SignalListItemFactory { let factory = gtk::SignalListItemFactory::new(); factory.connect_setup(|_, item| { let Some(item) = item.downcast_ref::() else { return; }; + let icon = gtk::Image::new(); + icon.add_css_class("dimmed"); + icon.set_accessible_role(gtk::AccessibleRole::Presentation); let name = gtk::Label::builder() .xalign(0.0) .ellipsize(gtk::pango::EllipsizeMode::End) @@ -224,34 +384,59 @@ fn factory() -> gtk::SignalListItemFactory { .build(); summary.add_css_class("caption"); summary.add_css_class("dimmed"); - let row = gtk::Box::builder() + let text = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(2) - .margin_top(6) - .margin_bottom(6) .build(); + text.append(&name); + text.append(&summary); + let row = gtk::Box::builder().spacing(8).margin_top(6).margin_bottom(6).build(); row.add_css_class(ROW); - row.append(&name); - row.append(&summary); - item.set_child(Some(&row)); + row.append(&icon); + row.append(&text); + let expander = gtk::TreeExpander::new(); + expander.set_child(Some(&row)); + item.set_child(Some(&expander)); }); factory.connect_bind(|_, item| { let Some(item) = item.downcast_ref::() else { return; }; - let (Some(object), Some(row)) = (item.item().and_downcast::(), item.child()) else { + let (Some(list_row), Some(expander)) = ( + item.item().and_downcast::(), + item.child().and_downcast::(), + ) else { return; }; - let favorite = object.borrow::().clone(); - row.set_widget_name(&favorite.id.to_string()); - if let (Some(name), Some(summary)) = ( - row.first_child().and_downcast::(), - row.last_child().and_downcast::(), - ) { - name.set_label(&favorite.name); - summary.set_label(favorite.summary()); + expander.set_list_row(Some(&list_row)); + let (Some(node), Some(row)) = (node_of(&list_row), expander.child()) else { + return; + }; + row.set_widget_name(&node.key()); + let (Some(icon), Some(text)) = (row.first_child().and_downcast::(), row.last_child()) else { + return; + }; + let (Some(name), Some(summary)) = ( + text.first_child().and_downcast::(), + text.last_child().and_downcast::(), + ) else { + return; + }; + match &node { + Node::Folder(folder) => { + icon.set_icon_name(Some("folder-symbolic")); + name.set_label(&folder.name); + summary.set_visible(false); + item.set_accessible_label(&folder.name); + } + Node::Query(query) => { + icon.set_icon_name(Some("text-x-generic-symbolic")); + name.set_label(&query.name); + summary.set_label(query.summary()); + summary.set_visible(true); + item.set_accessible_label(&query.name); + } } - item.set_accessible_label(&favorite.name); }); factory } diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 9e38c4d9fd..52dfe7d539 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -273,6 +273,34 @@ mod tests { wait_until(WAIT, || favorites.names().is_empty()).expect("the favorite to go"); } + /// Favorites are filed in folders: a folder is made, a query moved into + /// it, and deleting the folder leaves the query. + #[gtk4::test] + fn favorites_are_filed_in_folders_and_a_deleted_folder_leaves_its_queries() { + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let test = TestWindow::connected("FavoritesFolders"); + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("the query database to open"); + let shell = test.window.shell().expect("the shell"); + let favorites = shell.imp().favorites.get().cloned().expect("the favorites pane"); + shell.imp().scope_toggle.set_active_name(Some("favorites")); + test.workspace() + .with_model(|model| model.on_save_query_named("Orders".to_owned(), "SELECT 1".to_owned())); + wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); + + shell.create_folder("Reports".to_owned(), None); + wait_until(WAIT, || favorites.folders().len() == 1).expect("the folder to be listed"); + let folder = favorites.folders()[0].id; + shell.move_favorite(favorites.ids()[0], Some(folder)); + wait_until(WAIT, || favorites.folder_of_first_query() == Some(folder)).expect("the query filed in it"); + + shell.delete_folder(folder); + wait_until(WAIT, || favorites.folders().is_empty()).expect("the folder to go"); + assert_eq!(favorites.names(), ["Orders"], "the query went with its folder"); + assert_eq!(favorites.folder_of_first_query(), None); + } + #[gtk4::test] fn a_history_dialog_closed_by_hand_is_not_closed_again_on_disconnect() { use gtk4::glib; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 07737cd228..8862872fbd 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -12,8 +12,8 @@ use libadwaita as adw; use libadwaita::prelude::{AdwDialogExt, AlertDialogExt, BinExt, PreferencesGroupExt}; use tablepro_core::DataModel; use tablepro_session::SessionKey; -use tablepro_storage::SavedQueries; -use tablepro_storage::saved_queries::SavedQuery; +use tablepro_storage::QueryHistory; +use tablepro_storage::saved_queries::{SavedQuery, SavedQueryFolder}; use uuid::Uuid; use super::health_banner::REVIEW_HOST_KEY; @@ -583,19 +583,21 @@ impl WorkspaceShell { SessionKey::File(_) => None, }); let Some(connection) = connection else { - pane.show(Vec::new()); + pane.show(Vec::new(), Vec::new()); return; }; let ready = history.ready_store(); crate::runtime::spawn_and_deliver( tasks, async move { - let store = ready.await?.saved_queries(); - store.list(Some(connection)).await.ok() + let history = ready.await?; + let queries = history.saved_queries().list(Some(connection)).await.ok()?; + let folders = history.saved_query_folders().list(connection).await.ok()?; + Some((queries, folders)) }, move |listed| { - if let Ok(Some(favorites)) = listed { - pane.show(favorites); + if let Ok(Some((queries, folders))) = listed { + pane.show(queries, folders); } }, ); @@ -612,6 +614,10 @@ impl WorkspaceShell { } FavoriteAction::Rename(favorite) => self.ask_favorite_name(favorite), FavoriteAction::Delete(favorite) => self.ask_favorite_deletion(favorite), + FavoriteAction::MoveTo(favorite) => self.ask_folder_for(favorite), + FavoriteAction::NewFolder(parent) => self.ask_folder_name(parent, None), + FavoriteAction::RenameFolder(folder) => self.ask_folder_name(None, Some(folder)), + FavoriteAction::DeleteFolder(folder) => self.ask_folder_deletion(folder), } } @@ -662,21 +668,170 @@ impl WorkspaceShell { pub(crate) fn rename_favorite(&self, id: i64, name: String) { self.change_favorites( - async move |store| store.rename(id, &name).await, + async move |history| history.saved_queries().rename(id, &name).await, gettext("Could not rename that saved query."), ); } pub(crate) fn delete_favorite(&self, id: i64) { self.change_favorites( - async move |store| store.delete(id).await, + async move |history| history.saved_queries().delete(id).await, gettext("Could not delete that saved query."), ); } - /// Run `change` on the saved queries, then read the list again, or - /// say `failure`. - fn change_favorites(&self, change: impl FnOnce(SavedQueries) -> W + Send + 'static, failure: String) + pub(crate) fn move_favorite(&self, id: i64, folder: Option) { + self.change_favorites( + async move |history| history.saved_queries().move_to_folder(id, folder, None).await, + gettext("Could not move that saved query."), + ); + } + + pub(crate) fn create_folder(&self, name: String, parent: Option) { + let Some(connection) = self.front_connection() else { + return; + }; + self.change_favorites( + async move |history| { + history + .saved_query_folders() + .create(connection, &name, parent) + .await + .map(drop) + }, + gettext("Could not make that folder."), + ); + } + + fn rename_folder(&self, id: i64, name: String) { + self.change_favorites( + async move |history| history.saved_query_folders().rename(id, &name).await, + gettext("Could not rename that folder."), + ); + } + + pub(crate) fn delete_folder(&self, id: i64) { + self.change_favorites( + async move |history| history.saved_query_folders().delete(id).await, + gettext("Could not delete that folder."), + ); + } + + /// The connection whose favorites the sidebar lists. + fn front_connection(&self) -> Option { + self.front().and_then(|front| front.key()).and_then(|key| match key { + SessionKey::Saved(id) | SessionKey::SavedIn { id, .. } => Some(id), + SessionKey::File(_) => None, + }) + } + + /// A name for a folder: a new one inside `parent`, or the new name of `rename`. + fn ask_folder_name(&self, parent: Option, rename: Option) { + let title = match (&rename, &parent) { + (Some(_), _) => gettext("Rename Folder"), + (None, Some(_)) => gettext("New Subfolder"), + (None, None) => gettext("New Folder"), + }; + let verb = if rename.is_some() { + gettext("Rename") + } else { + gettext("Create") + }; + let dialog = adw::AlertDialog::new(Some(&title), None); + let entry = adw::EntryRow::builder() + .title(gettext("Name")) + .activates_default(true) + .build(); + if let Some(folder) = &rename { + entry.set_text(&folder.name); + } + let group = adw::PreferencesGroup::new(); + group.add(&entry); + dialog.set_extra_child(Some(&group)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("ok", &verb); + dialog.set_response_appearance("ok", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("ok")); + dialog.set_close_response("cancel"); + crate::ui::name_entry::require_name(&dialog, "ok", &entry); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let name = entry.text().trim().to_owned(); + let Some(shell) = shell.upgrade().filter(|_| response == "ok") else { + return; + }; + match &rename { + Some(folder) if name != folder.name => shell.rename_folder(folder.id, name), + Some(_) => {} + None => shell.create_folder(name, parent.as_ref().map(|folder| folder.id)), + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + fn ask_folder_deletion(&self, folder: SavedQueryFolder) { + let dialog = adw::AlertDialog::new( + Some(&gettext_f("Delete “{name}”?", &[("name", &folder.name)])), + Some(&gettext( + "The folders in it are deleted too. The saved queries in them stay, at the top.", + )), + ); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("delete", &gettext("Delete")); + dialog.set_response_appearance("delete", adw::ResponseAppearance::Destructive); + dialog.set_default_response(Some("cancel")); + dialog.set_close_response("cancel"); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + if let (true, Some(shell)) = (response == "delete", shell.upgrade()) { + shell.delete_folder(folder.id); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + /// Pick the folder a query is filed in, or the top. + fn ask_folder_for(&self, favorite: SavedQuery) { + let Some(pane) = self.imp().favorites.get().cloned() else { + return; + }; + let mut folders = pane.folders(); + folders.sort_by_key(|folder| folder.name.to_lowercase()); + let top = gettext("No Folder"); + let names: Vec<&str> = std::iter::once(top.as_str()) + .chain(folders.iter().map(|folder| folder.name.as_str())) + .collect(); + let choice = gtk::DropDown::from_strings(&names); + choice.update_property(&[gtk::accessible::Property::Label(&gettext("Folder"))]); + let at = favorite + .folder_id + .and_then(|id| folders.iter().position(|folder| folder.id == id)) + .map_or(0, |position| position + 1); + choice.set_selected(u32::try_from(at).unwrap_or(0)); + let dialog = adw::AlertDialog::new(Some(&gettext_f("Move “{name}”", &[("name", &favorite.name)])), None); + dialog.set_extra_child(Some(&choice)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("move", &gettext("Move")); + dialog.set_response_appearance("move", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("move")); + dialog.set_close_response("cancel"); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let Some(shell) = shell.upgrade().filter(|_| response == "move") else { + return; + }; + let folder = match choice.selected() { + 0 => None, + at => folders.get(at as usize - 1).map(|folder| folder.id), + }; + shell.move_favorite(favorite.id, folder); + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + /// Run `change` on the history database, then read the list again, or + /// say why it did not work. + fn change_favorites(&self, change: impl FnOnce(QueryHistory) -> W + Send + 'static, failure: String) where W: std::future::Future> + Send + 'static, { @@ -688,17 +843,21 @@ impl WorkspaceShell { crate::runtime::spawn_and_deliver( tasks, async move { - let store = ready.await?.saved_queries(); - change(store).await.ok() + let history = ready.await.ok_or(tablepro_storage::StorageError::NotInitialised)?; + change(history).await }, move |done| { let Some(shell) = shell.upgrade() else { return; }; - match done { - Ok(Some(())) => shell.reload_favorites(), - _ => shell.toast_overlay().add_toast(crate::ui::plain_toast(&failure)), - } + let message = match done { + Ok(Ok(())) => return shell.reload_favorites(), + Ok(Err(tablepro_storage::StorageError::FolderNameTaken)) => { + gettext("A folder with that name is already there.") + } + _ => failure, + }; + shell.toast_overlay().add_toast(crate::ui::plain_toast(&message)); }, ); } From b410095bef143ddd2533f17a5d15f63d47c2ba2f Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:30:53 +0100 Subject: [PATCH 12/23] fix(linux-sidebar): name the New Folder button --- linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 94c320d071..af9ad4c5b4 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -170,7 +170,6 @@ impl FavoritesPane { stack.set_vexpand(true); let new_folder = gtk::Button::builder() - .label(gettext("New Folder")) .icon_name("folder-new-symbolic") .halign(gtk::Align::Start) .margin_top(6) @@ -178,6 +177,8 @@ impl FavoritesPane { .margin_start(6) .build(); new_folder.add_css_class("flat"); + new_folder.set_tooltip_text(Some(&gettext("New Folder"))); + new_folder.update_property(&[gtk::accessible::Property::Label(&gettext("New Folder"))]); new_folder.connect_clicked({ let asked = asked.clone(); move |_| asked(FavoriteAction::NewFolder(None)) From 33fcedc66625b9ae2557e52b8ff3102d3908fa32 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:30:59 +0100 Subject: [PATCH 13/23] docs(linux-sidebar): add the changelog entry --- linux/changelog.d/4130.added.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 linux/changelog.d/4130.added.md diff --git a/linux/changelog.d/4130.added.md b/linux/changelog.d/4130.added.md new file mode 100644 index 0000000000..c976171068 --- /dev/null +++ b/linux/changelog.d/4130.added.md @@ -0,0 +1 @@ +Favorites are filed in folders that nest, made, renamed and deleted from the list. From 8f1cf1ab16a1de7af67a93e7f18103229c0c85df Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 21:12:31 +0700 Subject: [PATCH 14/23] fix(linux-sidebar): account for workspace dispatcher size --- linux/crates/app/src/ui/workspace/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 9afe573224..b7737b5a33 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -1324,6 +1324,7 @@ impl WorkspaceModel { } } + #[expect(clippy::too_many_lines, reason = "Each workspace input dispatches to its own handler")] fn update(&mut self, msg: WorkspaceInput) { match msg { WorkspaceInput::HealthChanged(health) => self.refresh_health_banner(&health), From 60415ce4a09d711c4c825ccb18f3013a31472d2d Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 21:36:48 +0700 Subject: [PATCH 15/23] fix(linux-sidebar): include stable identity dependency notices --- linux/about.toml | 7 ++ linux/build-aux/debian/copyright | 66 ++++++++++ linux/crates/app/src/ui/workspace/mod.rs | 5 +- linux/data/licenses/THIRD-PARTY-NOTICE.md | 140 ++++++++++++++++++++++ linux/data/licenses/third-party.json | 17 +++ 5 files changed, 234 insertions(+), 1 deletion(-) diff --git a/linux/about.toml b/linux/about.toml index 1e4cdb7d4a..eb8fb0dbb3 100644 --- a/linux/about.toml +++ b/linux/about.toml @@ -230,3 +230,10 @@ license = "Apache-2.0" [[sync_wrapper.clarify.files]] path = "LICENSE" checksum = "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594" + +# cargo-about cannot identify the combined BSD and MIT license text. +[sha1_smol.clarify] +license = "BSD-3-Clause AND MIT" +[[sha1_smol.clarify.files]] +path = "LICENSE" +checksum = "282a21b0710441c364025461a447362daf18f5798a7b72ae2f801a2aa536da51" diff --git a/linux/build-aux/debian/copyright b/linux/build-aux/debian/copyright index 800d5c6bc2..ca9916a5d4 100644 --- a/linux/build-aux/debian/copyright +++ b/linux/build-aux/debian/copyright @@ -18754,6 +18754,72 @@ License: Apache-2.0 or Expat OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +Files: vendor/sha1_smol-1.0.1/* +Copyright: 2018, the respective contributors, as shown by the AUTHORS file. + 2006-2009 Graydon Hoare + 2009-2013 Mozilla Foundation +License: BSD-3-Clause and Expat + BSD 3-Clause License + . + Copyright (c) 2018, the respective contributors, as shown by the AUTHORS file. + All rights reserved. + . + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + . + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + . + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + . + * Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + . + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + . + ----- + . + src/simd.rs is licensed under the MIT license: + . + Copyright (c) 2006-2009 Graydon Hoare + Copyright (c) 2009-2013 Mozilla Foundation + . + Permission is hereby granted, free of charge, to any + person obtaining a copy of this software and associated + documentation files (the "Software"), to deal in the + Software without restriction, including without + limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of + the Software, and to permit persons to whom the Software + is furnished to do so, subject to the following + conditions: + . + The above copyright notice and this permission notice + shall be included in all copies or substantial portions + of the Software. + . + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF + ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED + TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A + PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT + SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR + IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + Files: vendor/sha3-0.12.0/* Copyright: 2020-2026 The RustCrypto Project Developers 2016-2023 Artyom Pavlov, Marek Kotewicz diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index b7737b5a33..ca710b78be 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -1324,7 +1324,10 @@ impl WorkspaceModel { } } - #[expect(clippy::too_many_lines, reason = "Each workspace input dispatches to its own handler")] + #[expect( + clippy::too_many_lines, + reason = "Each workspace input dispatches to its own handler" + )] fn update(&mut self, msg: WorkspaceInput) { match msg { WorkspaceInput::HealthChanged(health) => self.refresh_health_banner(&health), diff --git a/linux/data/licenses/THIRD-PARTY-NOTICE.md b/linux/data/licenses/THIRD-PARTY-NOTICE.md index da91cefa2c..5388810773 100644 --- a/linux/data/licenses/THIRD-PARTY-NOTICE.md +++ b/linux/data/licenses/THIRD-PARTY-NOTICE.md @@ -2585,6 +2585,76 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI Used by: +- sha1_smol 1.0.1 + +~~~~text +BSD 3-Clause License + +Copyright (c) 2018, the respective contributors, as shown by the AUTHORS file. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +----- + +src/simd.rs is licensed under the MIT license: + +Copyright (c) 2006-2009 Graydon Hoare +Copyright (c) 2009-2013 Mozilla Foundation + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +~~~~ + +### BSD 3-Clause "New" or "Revised" License + +Used by: + - subtle 2.6.1 ~~~~text @@ -4064,6 +4134,76 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI Used by: +- sha1_smol 1.0.1 + +~~~~text +BSD 3-Clause License + +Copyright (c) 2018, the respective contributors, as shown by the AUTHORS file. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +----- + +src/simd.rs is licensed under the MIT license: + +Copyright (c) 2006-2009 Graydon Hoare +Copyright (c) 2009-2013 Mozilla Foundation + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +~~~~ + +### MIT License + +Used by: + - sqlx-core 0.9.0 - sqlx-macros-core 0.9.0 - sqlx-macros 0.9.0 diff --git a/linux/data/licenses/third-party.json b/linux/data/licenses/third-party.json index 62c678807d..cef205f7b9 100644 --- a/linux/data/licenses/third-party.json +++ b/linux/data/licenses/third-party.json @@ -108,6 +108,14 @@ { "crate": { "name": "aws-lc-sys", "version": "0.45.0" } } ] }, + { + "id": "BSD-3-Clause", + "name": "BSD 3-Clause \"New\" or \"Revised\" License", + "text": "BSD 3-Clause License\n\nCopyright (c) 2018, the respective contributors, as shown by the AUTHORS file.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n-----\n\nsrc/simd.rs is licensed under the MIT license:\n\nCopyright (c) 2006-2009 Graydon Hoare\nCopyright (c) 2009-2013 Mozilla Foundation\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentation files (the \"Software\"), to deal in the\nSoftware without restriction, including without\nlimitation the rights to use, copy, modify, merge,\npublish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software\nis furnished to do so, subject to the following\nconditions:\n\nThe above copyright notice and this permission notice\nshall be included in all copies or substantial portions\nof the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\nTO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\nSHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\nIN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n", + "used_by": [ + { "crate": { "name": "sha1_smol", "version": "1.0.1" } } + ] + }, { "id": "BSD-3-Clause", "name": "BSD 3-Clause \"New\" or \"Revised\" License", @@ -238,6 +246,14 @@ { "crate": { "name": "aws-lc-sys", "version": "0.45.0" } } ] }, + { + "id": "MIT", + "name": "MIT License", + "text": "BSD 3-Clause License\n\nCopyright (c) 2018, the respective contributors, as shown by the AUTHORS file.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n-----\n\nsrc/simd.rs is licensed under the MIT license:\n\nCopyright (c) 2006-2009 Graydon Hoare\nCopyright (c) 2009-2013 Mozilla Foundation\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentation files (the \"Software\"), to deal in the\nSoftware without restriction, including without\nlimitation the rights to use, copy, modify, merge,\npublish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software\nis furnished to do so, subject to the following\nconditions:\n\nThe above copyright notice and this permission notice\nshall be included in all copies or substantial portions\nof the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\nTO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\nSHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\nIN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n", + "used_by": [ + { "crate": { "name": "sha1_smol", "version": "1.0.1" } } + ] + }, { "id": "MIT", "name": "MIT License", @@ -3013,6 +3029,7 @@ { "name": "serde_with", "version": "3.23.0", "license": "MIT OR Apache-2.0" }, { "name": "serde_with_macros", "version": "3.23.0", "license": "MIT OR Apache-2.0" }, { "name": "sha1", "version": "0.11.0", "license": "MIT OR Apache-2.0" }, + { "name": "sha1_smol", "version": "1.0.1", "license": "BSD-3-Clause AND MIT" }, { "name": "sha2", "version": "0.10.9", "license": "MIT OR Apache-2.0" }, { "name": "sha2", "version": "0.11.0", "license": "MIT OR Apache-2.0" }, { "name": "sharded-slab", "version": "0.1.7", "license": "MIT" }, From d116651b73c5fffce1dacb9fe40785ed6dd0de59 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 22:25:42 +0700 Subject: [PATCH 16/23] test(linux-sidebar): wait for window teardown before counting query holds --- linux/crates/app/src/ui/workspace/workspace_shell.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 9a044e26bf..4d0c74bbfd 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -1120,6 +1120,8 @@ mod tests { assert_eq!(test.hold.live(), 1); test.window.close(); wait_until(WAIT, || !test.window.is_visible()).expect("window closed"); + // Session teardown and workspace flushes hold the process independently of this write. + wait_until(WAIT, || test.hold.live() <= 1).expect("window teardown complete"); assert_eq!(test.hold.live(), 1, "closing the window released an unfinished write"); release.send(()).expect("write still running"); wait_until(WAIT, || test.hold.live() == 0).expect("write complete"); From 8dc58152a66dc55279d0f8cb82ff348c09063502 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 22:31:14 +0700 Subject: [PATCH 17/23] test(linux-sidebar): track the favorite write hold independently --- .../app/src/ui/session_window/tests/mod.rs | 53 +++++++++++++++++-- .../app/src/ui/workspace/workspace_shell.rs | 9 ++-- 2 files changed, 55 insertions(+), 7 deletions(-) diff --git a/linux/crates/app/src/ui/session_window/tests/mod.rs b/linux/crates/app/src/ui/session_window/tests/mod.rs index 86d2581e36..5153dcdd3a 100644 --- a/linux/crates/app/src/ui/session_window/tests/mod.rs +++ b/linux/crates/app/src/ui/session_window/tests/mod.rs @@ -3,7 +3,8 @@ mod open_file; mod other_databases; mod sessions; -use std::rc::Rc; +use std::cell::RefCell; +use std::rc::{Rc, Weak}; use std::sync::Arc; use std::time::Duration; @@ -14,7 +15,7 @@ use tablepro_core::credentials::{SecretError, SecretKind, SecretSave}; use tablepro_core::{AuthMode, DriverError, DriverRegistry, FileEndpoint, LivenessPolicy, TlsConfig}; use tablepro_session::fakes::{FakeConnector, FakeCredentialSource, FakeEstablish}; use tablepro_session::operation::DefaultDeadlines; -use tablepro_session::runtime::CountingHold; +use tablepro_session::runtime::{CountingHold, HoldToken, ProcessHold}; use tablepro_session::{ConnectError, CredentialSource, SessionKey}; use tablepro_storage::{SavedConnection, StoragePaths}; use tablepro_test_support::{ @@ -77,6 +78,7 @@ pub(crate) struct TestWindow { pub window: SessionWindow, pub services: Rc, pub hold: Rc, + pub hold_tokens: Rc>>>, pub connector: FakeConnector, pub saved: SavedConnection, /// The keyring every saved connection reads, unless the script @@ -87,6 +89,46 @@ pub(crate) struct TestWindow { _dir: tempfile::TempDir, } +struct TrackedHold { + count: Rc, + tokens: Rc>>>, +} + +impl TrackedHold { + fn new(count: Rc) -> Self { + Self { + count, + tokens: Rc::default(), + } + } +} + +impl ProcessHold for TrackedHold { + fn acquire(&self) -> HoldToken { + let identity = Rc::new(()); + self.tokens.borrow_mut().push(Rc::downgrade(&identity)); + HoldToken::new((self.count.acquire(), identity)) + } +} + +#[test] +fn hold_identity_distinguishes_a_released_write_from_other_live_work() { + let count = Rc::new(CountingHold::new()); + let hold = TrackedHold::new(count.clone()); + let write = hold.acquire(); + let identity = hold.tokens.borrow().last().expect("write token").clone(); + let cleanup = hold.acquire(); + assert!(identity.upgrade().is_some()); + drop(write); + assert_eq!(count.live(), 1); + assert!( + identity.upgrade().is_none(), + "cleanup must not keep the write's token alive" + ); + drop(cleanup); + assert_eq!(count.live(), 0); +} + impl TestWindow { pub(crate) fn picker(name: &str) -> Self { Self::with_script(name, Script::default()) @@ -150,6 +192,8 @@ impl TestWindow { let connector = FakeConnector::new(establish).always(FakeEstablish::Connect(connection)); let liveness = LivenessPolicy::DESKTOP; let hold = Rc::new(CountingHold::new()); + let tracked_hold = TrackedHold::new(hold.clone()); + let hold_tokens = tracked_hold.tokens.clone(); let parts = AppServicesParts { drivers, connector: Arc::new(connector.clone()), @@ -159,7 +203,7 @@ impl TestWindow { storage, tasks: runtime.tasks(), }; - let mut services = scripted_services(parts, hold.clone(), credentials, ssh); + let mut services = scripted_services(parts, Rc::new(tracked_hold), credentials, ssh); if let Some(revealer) = revealer { services.file_revealer = revealer; } @@ -170,6 +214,7 @@ impl TestWindow { window, services, hold, + hold_tokens, connector, saved, vault, @@ -287,7 +332,7 @@ fn write_unreadable_list(list_file: &std::path::Path) { fn scripted_services( parts: AppServicesParts, - hold: Rc, + hold: Rc, credentials: Option, ssh: Option, ) -> AppServices { diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 4d0c74bbfd..ffd6710feb 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -1118,12 +1118,15 @@ mod tests { "Rename failed".to_owned(), ); assert_eq!(test.hold.live(), 1); + let write_hold = test.hold_tokens.borrow().last().expect("rename hold").clone(); test.window.close(); wait_until(WAIT, || !test.window.is_visible()).expect("window closed"); - // Session teardown and workspace flushes hold the process independently of this write. - wait_until(WAIT, || test.hold.live() <= 1).expect("window teardown complete"); - assert_eq!(test.hold.live(), 1, "closing the window released an unfinished write"); + assert!( + write_hold.upgrade().is_some(), + "closing the window released the rename's hold" + ); release.send(()).expect("write still running"); + wait_until(WAIT, || write_hold.upgrade().is_none()).expect("rename hold released"); wait_until(WAIT, || test.hold.live() == 0).expect("write complete"); let store = test.services.history().store().expect("history").saved_queries(); let reading = test.services.tasks.spawn_task(async move { store.get(id).await }); From eb97aa4cd6eb46a2d24f70ff89d1a15432f15101 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 02:29:52 +0700 Subject: [PATCH 18/23] fix(core-storage): keep favorite mutations and recovery copies consistent --- .../20261109000000_favourites_order.sql | 23 + core/crates/storage/src/error.rs | 4 + core/crates/storage/src/favourites.rs | 339 +++++++++++-- core/crates/storage/src/lib.rs | 2 +- .../src/query_history/backup_folders.rs | 337 +++++++++++++ .../favourites_migration_tests.rs | 181 +++++++ core/crates/storage/src/query_history/mod.rs | 57 ++- .../storage/src/saved_queries/deletion.rs | 160 +++++++ .../storage/src/saved_queries/folders.rs | 230 +++++---- .../src/saved_queries/folders_tests.rs | 273 +++++++++++ core/crates/storage/src/saved_queries/mod.rs | 452 +++++++++--------- .../storage/src/saved_queries/ordering.rs | 53 ++ .../src/saved_queries/ordering_tests.rs | 296 ++++++++++++ .../storage/src/saved_queries/saved_query.rs | 11 - core/docs/decisions/0017-favourites.md | 12 +- linux/changelog.d/4116.changed.md | 1 + linux/docs/storage.md | 3 +- 17 files changed, 2052 insertions(+), 382 deletions(-) create mode 100644 core/crates/storage/migrations/20261109000000_favourites_order.sql create mode 100644 core/crates/storage/src/query_history/backup_folders.rs create mode 100644 core/crates/storage/src/query_history/favourites_migration_tests.rs create mode 100644 core/crates/storage/src/saved_queries/deletion.rs create mode 100644 core/crates/storage/src/saved_queries/folders_tests.rs create mode 100644 core/crates/storage/src/saved_queries/ordering.rs create mode 100644 core/crates/storage/src/saved_queries/ordering_tests.rs create mode 100644 linux/changelog.d/4116.changed.md diff --git a/core/crates/storage/migrations/20261109000000_favourites_order.sql b/core/crates/storage/migrations/20261109000000_favourites_order.sql new file mode 100644 index 0000000000..8c2c1e3b3a --- /dev/null +++ b/core/crates/storage/migrations/20261109000000_favourites_order.sql @@ -0,0 +1,23 @@ +WITH positions AS ( + SELECT id, ROW_NUMBER() OVER ( + PARTITION BY connection_id, folder_id + ORDER BY sort_order, name COLLATE NOCASE, id + ) - 1 AS position + FROM saved_queries +) +UPDATE saved_queries SET sort_order = positions.position +FROM positions WHERE saved_queries.id = positions.id; + +WITH positions AS ( + SELECT id, ROW_NUMBER() OVER ( + PARTITION BY connection_id, parent_id + ORDER BY sort_order, name COLLATE NOCASE, id + ) - 1 AS position + FROM saved_query_folders +) +UPDATE saved_query_folders SET sort_order = positions.position +FROM positions WHERE saved_query_folders.id = positions.id; + +CREATE INDEX saved_queries_folder_order_idx ON saved_queries (connection_id, folder_id, sort_order, id); +CREATE INDEX saved_query_folders_parent_idx ON saved_query_folders (parent_id); +CREATE INDEX saved_query_folders_order_idx ON saved_query_folders (connection_id, parent_id, sort_order, id); diff --git a/core/crates/storage/src/error.rs b/core/crates/storage/src/error.rs index 4fab9e196d..e76a03eb55 100644 --- a/core/crates/storage/src/error.rs +++ b/core/crates/storage/src/error.rs @@ -56,6 +56,9 @@ pub enum StorageError { #[error("a keyword is one word of at most {max} characters, with no spaces")] KeywordInvalid { max: usize }, + #[error("the folder name contains a control character")] + FolderNameInvalid, + #[error("another folder in the same place has that name")] FolderNameTaken, @@ -118,6 +121,7 @@ impl StorageError { Self::TagNameTaken => "storage.tag_name_taken", Self::KeywordTaken => "storage.keyword_taken", Self::KeywordInvalid { .. } => "storage.keyword_invalid", + Self::FolderNameInvalid => "storage.folder_name_invalid", Self::FolderNameTaken => "storage.folder_name_taken", Self::FolderCycle { .. } => "storage.folder_cycle", Self::Encode(..) => "storage.encode", diff --git a/core/crates/storage/src/favourites.rs b/core/crates/storage/src/favourites.rs index 5fb67a390c..bba38b38c9 100644 --- a/core/crates/storage/src/favourites.rs +++ b/core/crates/storage/src/favourites.rs @@ -1,17 +1,14 @@ -//! The tables and databases a user marks as favourites on a connection, -//! as the macOS sidebar keeps them (core ADR 0017). - use std::path::PathBuf; +use std::sync::Arc; use std::time::SystemTime; -use sqlx::{Row, SqlitePool}; +use sqlx::{AssertSqlSafe, Connection, Row, SqlitePool}; +use tokio::sync::watch; use uuid::Uuid; use crate::error::StorageError; use crate::unix_time::to_unix; -/// What a favourite database is for, the buckets the macOS list groups -/// them in. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum DatabaseEnvironment { Development, @@ -21,7 +18,6 @@ pub enum DatabaseEnvironment { } impl DatabaseEnvironment { - /// The word stored, which is also the macOS raw value. pub fn as_str(self) -> &'static str { match self { Self::Development => "development", @@ -38,8 +34,6 @@ impl DatabaseEnvironment { } } -/// A table marked as a favourite, named as the catalogue names it: the -/// database and schema where the engine has them. #[derive(Debug, Clone, PartialEq, Eq)] pub struct FavouriteTable { pub connection_id: Uuid, @@ -55,40 +49,55 @@ pub struct FavouriteDatabase { pub environment: DatabaseEnvironment, } -/// The favourite tables and databases. Cloning shares the pool with the -/// history it lives beside. #[derive(Debug, Clone)] pub struct Favourites { pool: SqlitePool, - // The database's file, whose upgrade copies a removal reaches too. path: PathBuf, + changes: Arc>, } impl Favourites { - pub(crate) fn new(pool: SqlitePool, path: PathBuf) -> Self { - Self { pool, path } + pub(crate) fn new(pool: SqlitePool, path: PathBuf, changes: Arc>) -> Self { + Self { pool, path, changes } + } + + pub fn changes(&self) -> watch::Receiver { + self.changes.subscribe() + } + + fn changed(&self) { + self.changes + .send_modify(|revision| *revision = revision.wrapping_add(1)); } - /// Mark a table. Marking one already marked changes nothing. pub async fn add_table(&self, table: &FavouriteTable) -> Result<(), StorageError> { - if table.name.trim().is_empty() { + if table.name.is_empty() { return Err(StorageError::EmptyName); } - sqlx::query( - "INSERT OR IGNORE INTO favourite_tables (connection_id, database, schema, name, created_at) \ - VALUES (?, ?, ?, ?, ?)", + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let affected = sqlx::query( + "INSERT INTO favourite_tables (connection_id, database, schema, name, created_at) \ + VALUES (?, ?, ?, ?, ?) ON CONFLICT (connection_id, database, schema, name) DO NOTHING", ) .bind(table.connection_id.to_string()) .bind(table.database.as_deref().unwrap_or_default()) .bind(table.schema.as_deref().unwrap_or_default()) .bind(&table.name) .bind(to_unix(SystemTime::now())) - .execute(&self.pool) - .await?; + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } Ok(()) } pub async fn remove_table(&self, table: &FavouriteTable) -> Result<(), StorageError> { + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; crate::query_history::trim_upgrade_copies( &self.path, &[crate::query_history::CopyDelete { @@ -105,19 +114,23 @@ impl Favourites { }], ) .await?; - sqlx::query( + let affected = sqlx::query( "DELETE FROM favourite_tables WHERE connection_id = ? AND database = ? AND schema = ? AND name = ?", ) .bind(table.connection_id.to_string()) .bind(table.database.as_deref().unwrap_or_default()) .bind(table.schema.as_deref().unwrap_or_default()) .bind(&table.name) - .execute(&self.pool) - .await?; + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } Ok(()) } - /// The connection's favourite tables, by database, schema and name. pub async fn tables(&self, connection: Uuid) -> Result, StorageError> { let rows = sqlx::query( "SELECT database, schema, name FROM favourite_tables WHERE connection_id = ? \ @@ -139,31 +152,40 @@ impl Favourites { .collect() } - /// Mark a database, or change the environment of one marked. pub async fn set_database( &self, connection: Uuid, database: &str, environment: DatabaseEnvironment, ) -> Result<(), StorageError> { - if database.trim().is_empty() { + if database.is_empty() { return Err(StorageError::EmptyName); } - sqlx::query( + let mut held = self.pool.acquire().await?; + let mut transaction = held.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let affected = sqlx::query( "INSERT INTO favourite_databases (connection_id, database, environment, created_at) \ VALUES (?, ?, ?, ?) \ - ON CONFLICT (connection_id, database) DO UPDATE SET environment = excluded.environment", + ON CONFLICT (connection_id, database) DO UPDATE SET environment = excluded.environment \ + WHERE favourite_databases.environment <> excluded.environment", ) .bind(connection.to_string()) .bind(database) .bind(environment.as_str()) .bind(to_unix(SystemTime::now())) - .execute(&self.pool) - .await?; + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } Ok(()) } pub async fn remove_database(&self, connection: Uuid, database: &str) -> Result<(), StorageError> { + let mut held = self.pool.acquire().await?; + let mut transaction = held.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; crate::query_history::trim_upgrade_copies( &self.path, &[crate::query_history::CopyDelete { @@ -176,15 +198,19 @@ impl Favourites { }], ) .await?; - sqlx::query("DELETE FROM favourite_databases WHERE connection_id = ? AND database = ?") + let affected = sqlx::query("DELETE FROM favourite_databases WHERE connection_id = ? AND database = ?") .bind(connection.to_string()) .bind(database) - .execute(&self.pool) - .await?; + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } Ok(()) } - /// The connection's favourite databases, by name. pub async fn databases(&self, connection: Uuid) -> Result, StorageError> { let rows = sqlx::query( "SELECT database, environment FROM favourite_databases WHERE connection_id = ? \ @@ -199,7 +225,8 @@ impl Favourites { Ok(FavouriteDatabase { connection_id: connection, database: row.try_get("database")?, - environment: DatabaseEnvironment::parse(&environment).unwrap_or(DatabaseEnvironment::Unassigned), + environment: DatabaseEnvironment::parse(&environment) + .ok_or_else(|| StorageError::Schema(format!("unknown database environment: {environment}")))?, }) }) .collect() @@ -222,4 +249,244 @@ mod tests { } assert_eq!(DatabaseEnvironment::parse("staging"), None); } + + async fn history(root: &tempfile::TempDir) -> crate::QueryHistory { + crate::QueryHistory::open(&crate::StoragePaths::under( + root.path(), + "tablepro", + "app.tablepro.TablePro", + )) + .await + .expect("open history") + } + + fn table(connection_id: Uuid, database: Option<&str>, schema: Option<&str>, name: &str) -> FavouriteTable { + FavouriteTable { + connection_id, + database: database.map(str::to_owned), + schema: schema.map(str::to_owned), + name: name.to_owned(), + } + } + + #[tokio::test] + async fn catalog_names_keep_case_spaces_and_connection_database_and_schema_identity() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + let tables = [ + table(connection, Some(" shop "), Some("public"), "Orders"), + table(connection, Some("shop"), Some("public"), "Orders"), + table(connection, Some("shop"), Some("Public"), "Orders"), + table(connection, Some("shop"), Some("public"), "orders"), + table(connection, Some(" "), Some(" "), " "), + table(other, Some("shop"), Some("public"), "Orders"), + ]; + for table in &tables { + favourites.add_table(table).await.expect("add table"); + } + let found = favourites.tables(connection).await.expect("tables"); + assert_eq!(found.len(), tables.len() - 1); + assert!(tables[..5].iter().all(|table| found.contains(table))); + assert_eq!( + favourites.tables(other).await.expect("other tables"), + vec![tables[5].clone()] + ); + + favourites.remove_table(&tables[1]).await.expect("remove exact table"); + let found = favourites.tables(connection).await.expect("tables"); + assert_eq!(found.len(), 4); + assert!(!found.contains(&tables[1])); + assert!(found.contains(&tables[0])); + assert!(found.contains(&tables[2])); + assert!(found.contains(&tables[3])); + assert!(found.contains(&tables[4])); + + for name in [" ", "shop", "Shop", " shop "] { + favourites + .set_database(connection, name, DatabaseEnvironment::Testing) + .await + .expect("mark database"); + } + favourites + .set_database(other, "shop", DatabaseEnvironment::Production) + .await + .expect("other database"); + favourites + .remove_database(connection, "shop") + .await + .expect("remove database"); + let found = favourites.databases(connection).await.expect("databases"); + assert_eq!(found.len(), 3); + assert!( + [" ", "Shop", " shop "] + .iter() + .all(|name| found.iter().any(|db| db.database == *name)) + ); + assert_eq!(favourites.databases(other).await.expect("other databases").len(), 1); + } + + #[tokio::test] + async fn table_changes_notify_every_surface_only_when_committed_data_changes() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let mut changed = favourites.changes(); + let mut queries_changed = history.saved_queries().changes(); + let connection = Uuid::new_v4(); + let entry = table(connection, None, None, "orders"); + + favourites.add_table(&entry).await.expect("add"); + assert!(changed.has_changed().expect("revision")); + assert!(queries_changed.has_changed().expect("shared revision")); + assert_eq!( + favourites.tables(connection).await.expect("committed rows"), + vec![entry.clone()] + ); + changed.borrow_and_update(); + queries_changed.borrow_and_update(); + + favourites.add_table(&entry).await.expect("add again"); + favourites + .add_table(&table(connection, Some(""), Some(""), "orders")) + .await + .expect("empty namespace is absent namespace"); + assert!(!changed.has_changed().expect("no revision")); + assert!(!queries_changed.has_changed().expect("no shared revision")); + assert_eq!(favourites.tables(connection).await.expect("rows").len(), 1); + + favourites.remove_table(&entry).await.expect("remove"); + assert!(changed.has_changed().expect("revision")); + assert!(queries_changed.has_changed().expect("shared revision")); + assert!( + favourites + .tables(connection) + .await + .expect("committed removal") + .is_empty() + ); + changed.borrow_and_update(); + queries_changed.borrow_and_update(); + favourites.remove_table(&entry).await.expect("remove again"); + assert!(!changed.has_changed().expect("no revision")); + assert!(!queries_changed.has_changed().expect("no shared revision")); + } + + #[tokio::test] + async fn database_environment_changes_notify_but_repeated_assignments_do_not() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let mut changed = favourites.changes(); + let connection = Uuid::new_v4(); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Testing) + .await + .expect("mark database"); + assert!(changed.has_changed().expect("revision")); + changed.borrow_and_update(); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Testing) + .await + .expect("same environment"); + assert!(!changed.has_changed().expect("no revision")); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Production) + .await + .expect("change environment"); + assert!(changed.has_changed().expect("revision")); + assert_eq!( + favourites.databases(connection).await.expect("committed database"), + vec![FavouriteDatabase { + connection_id: connection, + database: "shop".to_owned(), + environment: DatabaseEnvironment::Production, + }] + ); + changed.borrow_and_update(); + favourites.remove_database(connection, "shop").await.expect("remove"); + assert!(changed.has_changed().expect("revision")); + changed.borrow_and_update(); + favourites + .remove_database(connection, "shop") + .await + .expect("remove again"); + assert!(!changed.has_changed().expect("no revision")); + } + + #[tokio::test] + async fn failed_writes_keep_data_and_publish_no_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let entry = table(connection, None, None, "orders"); + favourites.add_table(&entry).await.expect("add"); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Testing) + .await + .expect("mark database"); + sqlx::query("CREATE TRIGGER reject_table_delete BEFORE DELETE ON favourite_tables BEGIN SELECT RAISE(ABORT, 'denied'); END") + .execute(&favourites.pool) + .await + .expect("install failure"); + sqlx::query("CREATE TRIGGER reject_database_change BEFORE UPDATE ON favourite_databases BEGIN SELECT RAISE(ABORT, 'denied'); END") + .execute(&favourites.pool) + .await + .expect("install failure"); + let changed = favourites.changes(); + assert!(favourites.remove_table(&entry).await.is_err()); + assert!( + favourites + .set_database(connection, "shop", DatabaseEnvironment::Production) + .await + .is_err() + ); + assert!(matches!( + favourites.add_table(&table(connection, None, None, "")).await, + Err(StorageError::EmptyName) + )); + assert!(matches!( + favourites + .set_database(connection, "", DatabaseEnvironment::Testing) + .await, + Err(StorageError::EmptyName) + )); + assert!(!changed.has_changed().expect("no revision")); + assert_eq!( + favourites.tables(connection).await.expect("unchanged table"), + vec![entry] + ); + assert_eq!( + favourites.databases(connection).await.expect("unchanged database")[0].environment, + DatabaseEnvironment::Testing + ); + } + + #[tokio::test] + async fn corrupt_environment_is_an_error_instead_of_an_unassigned_database() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + sqlx::query("PRAGMA ignore_check_constraints = ON") + .execute(&favourites.pool) + .await + .expect("allow corrupt fixture"); + sqlx::query("INSERT INTO favourite_databases (connection_id, database, environment, created_at) VALUES (?, 'shop', 'unknown', 0)") + .bind(connection.to_string()) + .execute(&favourites.pool) + .await + .expect("corrupt fixture"); + sqlx::query("PRAGMA ignore_check_constraints = OFF") + .execute(&favourites.pool) + .await + .expect("restore constraints"); + assert!(matches!( + favourites.databases(connection).await, + Err(StorageError::Schema(_)) + )); + } } diff --git a/core/crates/storage/src/lib.rs b/core/crates/storage/src/lib.rs index d3543c442f..b0658e19fc 100644 --- a/core/crates/storage/src/lib.rs +++ b/core/crates/storage/src/lib.rs @@ -47,5 +47,5 @@ pub use group_name_error::GroupNameError; pub use group_tree::GroupTree; pub use paths::StoragePaths; pub use query_history::QueryHistory; -pub use saved_queries::{SavedQueries, SavedQueryFolder, SavedQueryFolders}; +pub use saved_queries::{SavedQueries, SavedQueriesSnapshot, SavedQueryFolder, SavedQueryFolders}; pub use tag_name_error::TagNameError; diff --git a/core/crates/storage/src/query_history/backup_folders.rs b/core/crates/storage/src/query_history/backup_folders.rs new file mode 100644 index 0000000000..fcb834fd25 --- /dev/null +++ b/core/crates/storage/src/query_history/backup_folders.rs @@ -0,0 +1,337 @@ +use sqlx::SqliteConnection; + +use crate::StorageError; + +pub(super) async fn reconcile(database: &mut SqliteConnection) -> Result { + let present: i64 = sqlx::query_scalar( + "SELECT (SELECT COUNT(*) FROM main.sqlite_master WHERE type = 'table' AND name = 'saved_query_folders') \ + * (SELECT COUNT(*) FROM live.sqlite_master WHERE type = 'table' AND name = 'saved_query_folders')", + ) + .fetch_one(&mut *database) + .await?; + if present == 0 { + return Ok(false); + } + + // A stale parent can otherwise delete a folder that moved out, or retain one that moved in. + // Replacing the graph also avoids transient sibling-name collisions and deep FK cascades. + sqlx::query( + "CREATE TEMP TABLE recovery_folders AS \ + WITH RECURSIVE kept(id) AS ( \ + SELECT old.id FROM main.saved_query_folders old \ + JOIN live.saved_query_folders live_folder ON live_folder.id = old.id \ + UNION \ + SELECT live_folder.parent_id FROM live.saved_query_folders live_folder \ + JOIN kept ON live_folder.id = kept.id WHERE live_folder.parent_id IS NOT NULL \ + ) \ + SELECT live_folder.* FROM live.saved_query_folders live_folder JOIN kept ON kept.id = live_folder.id", + ) + .execute(&mut *database) + .await?; + sqlx::query("DELETE FROM main.saved_query_folders") + .execute(&mut *database) + .await?; + sqlx::query( + "INSERT INTO main.saved_query_folders (id, connection_id, name, parent_id, sort_order, created_at, updated_at) \ + SELECT id, connection_id, name, parent_id, sort_order, created_at, updated_at FROM temp.recovery_folders", + ) + .execute(&mut *database) + .await?; + sqlx::query("DROP TABLE temp.recovery_folders") + .execute(&mut *database) + .await?; + Ok(true) +} + +pub(super) async fn repair_queries(database: &mut SqliteConnection) -> Result<(), StorageError> { + // Deleted folders leave recoverable query text after the existing root queries. + sqlx::query( + "WITH promoted AS MATERIALIZED ( \ + SELECT item.id, \ + COALESCE((SELECT MAX(root.sort_order) + 1 FROM main.saved_queries root \ + WHERE root.connection_id = item.connection_id AND root.folder_id IS NULL), 0) \ + + ROW_NUMBER() OVER (PARTITION BY item.connection_id ORDER BY item.folder_id, item.sort_order, item.id) - 1 \ + AS position \ + FROM main.saved_queries item \ + WHERE item.folder_id IS NOT NULL \ + AND NOT EXISTS (SELECT 1 FROM main.saved_query_folders folder WHERE folder.id = item.folder_id) \ + ) \ + UPDATE main.saved_queries SET folder_id = NULL, sort_order = (SELECT position FROM promoted WHERE id = saved_queries.id) \ + WHERE id IN (SELECT id FROM promoted)", + ) + .execute(&mut *database) + .await?; + sqlx::query( + "WITH positions AS MATERIALIZED ( \ + SELECT id, ROW_NUMBER() OVER (PARTITION BY connection_id, folder_id ORDER BY sort_order, name COLLATE NOCASE, id) - 1 AS position \ + FROM main.saved_queries \ + ) \ + UPDATE main.saved_queries SET sort_order = (SELECT position FROM positions WHERE id = saved_queries.id)", + ) + .execute(&mut *database) + .await?; + sqlx::query( + "WITH positions AS MATERIALIZED ( \ + SELECT id, ROW_NUMBER() OVER (PARTITION BY connection_id, parent_id ORDER BY sort_order, name COLLATE NOCASE, id) - 1 AS position \ + FROM main.saved_query_folders \ + ) \ + UPDATE main.saved_query_folders SET sort_order = (SELECT position FROM positions WHERE id = saved_query_folders.id)", + ) + .execute(&mut *database) + .await?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use std::path::Path; + + use sqlx::sqlite::SqliteConnectOptions; + use sqlx::{AssertSqlSafe, ConnectOptions, Connection, SqliteConnection}; + use uuid::Uuid; + + use crate::paths::StoragePaths; + use crate::query_history::{QueryHistory, trim_copy}; + use crate::saved_queries::NewSavedQuery; + + async fn history(root: &tempfile::TempDir) -> QueryHistory { + QueryHistory::open(&StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro")) + .await + .expect("open history") + } + + async fn copy_database(path: &Path) -> SqliteConnection { + SqliteConnectOptions::new() + .filename(path) + .read_only(true) + .connect() + .await + .expect("open copy") + } + + async fn save(history: &QueryHistory, name: &str, folder: Option) -> i64 { + let store = history.saved_queries(); + let id = store + .save(NewSavedQuery { + name: name.to_owned(), + query: format!("SELECT '{name}'"), + connection_id: Uuid::nil(), + connection_name: "local".to_owned(), + }) + .await + .expect("save query") + .id; + if folder.is_some() { + store.move_to_folder(id, folder, None).await.expect("file query"); + } + id + } + + #[tokio::test] + async fn a_copy_deletes_the_live_subtree_and_keeps_folders_that_moved_out() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let reports = folders.create(Uuid::nil(), "Reports", None).await.expect("root folder"); + let parent = folders.create(Uuid::nil(), "P", None).await.expect("parent"); + let moved_out = folders + .create(Uuid::nil(), "Reports", Some(parent)) + .await + .expect("nested folder with the same name"); + let moved_in = folders.create(Uuid::nil(), "Into", None).await.expect("moving folder"); + let root_query = save(&history, "root", None).await; + let kept_query = save(&history, "kept", Some(moved_out)).await; + let promoted_query = save(&history, "promoted", Some(moved_in)).await; + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("keep copy"); + + let archive = folders + .create(Uuid::nil(), "Archive", None) + .await + .expect("new ancestor"); + folders.move_to(moved_out, Some(archive)).await.expect("move out"); + folders.move_to(moved_in, Some(parent)).await.expect("move in"); + folders.delete(parent).await.expect("delete the live subtree"); + + let mut database = copy_database(©).await; + let stored: Vec<(i64, String, Option)> = + sqlx::query_as("SELECT id, name, parent_id FROM saved_query_folders ORDER BY id") + .fetch_all(&mut database) + .await + .expect("folders in copy"); + assert_eq!( + stored, + vec![ + (reports, "Reports".to_owned(), None), + (moved_out, "Reports".to_owned(), Some(archive)), + (archive, "Archive".to_owned(), None), + ] + ); + let queries: Vec<(i64, String, Option, i64)> = + sqlx::query_as("SELECT id, query, folder_id, sort_order FROM saved_queries ORDER BY id") + .fetch_all(&mut database) + .await + .expect("queries in copy"); + assert_eq!( + queries, + vec![ + (root_query, "SELECT 'root'".to_owned(), None, 0), + (kept_query, "SELECT 'kept'".to_owned(), Some(moved_out), 0), + (promoted_query, "SELECT 'promoted'".to_owned(), None, 1), + ] + ); + assert!( + sqlx::query("PRAGMA foreign_key_check") + .fetch_optional(&mut database) + .await + .expect("foreign keys") + .is_none() + ); + database.close().await.expect("close copy"); + } + + #[tokio::test] + async fn a_generic_sweep_keeps_a_moved_child_and_uses_its_current_name() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let root_folder = folders.create(Uuid::nil(), "Reports", None).await.expect("root folder"); + let parent = folders.create(Uuid::nil(), "P", None).await.expect("parent"); + let child = folders + .create(Uuid::nil(), "Reports", Some(parent)) + .await + .expect("child"); + let query = save(&history, "kept", Some(child)).await; + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("keep copy"); + folders.rename(root_folder, "Renamed").await.expect("rename root"); + folders.move_to(child, None).await.expect("reuse the former root name"); + sqlx::query("DELETE FROM saved_query_folders WHERE id = ?") + .bind(parent) + .execute(&history.pool) + .await + .expect("simulate a prior committed deletion"); + + let mut live = history.pool.acquire().await.expect("live connection"); + let transaction = live + .begin_with(AssertSqlSafe("BEGIN IMMEDIATE")) + .await + .expect("hold the live graph"); + trim_copy(©, history.path.to_str().expect("UTF-8 path"), &[]) + .await + .expect("trim copy"); + transaction.commit().await.expect("release live graph"); + + let mut database = copy_database(©).await; + let stored: Vec<(i64, String, Option)> = + sqlx::query_as("SELECT id, name, parent_id FROM saved_query_folders ORDER BY id") + .fetch_all(&mut database) + .await + .expect("folders"); + assert_eq!( + stored, + vec![ + (root_folder, "Renamed".to_owned(), None), + (child, "Reports".to_owned(), None) + ] + ); + let held: Option = sqlx::query_scalar("SELECT folder_id FROM saved_queries WHERE id = ?") + .bind(query) + .fetch_one(&mut database) + .await + .expect("query folder"); + assert_eq!(held, Some(child)); + database.close().await.expect("close copy"); + } + + #[tokio::test] + async fn a_copy_can_remove_more_folders_than_the_sqlite_cascade_limit() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let mut transaction = history.pool.begin().await.expect("begin fixture"); + let mut parent = None; + let mut first = None; + for _ in 0..1_100 { + let id = sqlx::query( + "INSERT INTO saved_query_folders (connection_id, name, parent_id, sort_order, created_at, updated_at) \ + VALUES (?, 'Nested', ?, 0, 1, 1)", + ) + .bind(Uuid::nil().to_string()) + .bind(parent) + .execute(&mut *transaction) + .await + .expect("insert folder") + .last_insert_rowid(); + first.get_or_insert(id); + parent = Some(id); + } + transaction.commit().await.expect("commit fixture"); + let query = save(&history, "deep", parent).await; + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("keep copy"); + history + .saved_query_folders() + .delete(first.expect("first folder")) + .await + .expect("delete deep subtree"); + + let mut database = copy_database(©).await; + let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM saved_query_folders") + .fetch_one(&mut database) + .await + .expect("folder count"); + assert_eq!(count, 0); + let stored: (String, Option, i64) = + sqlx::query_as("SELECT query, folder_id, sort_order FROM saved_queries WHERE id = ?") + .bind(query) + .fetch_one(&mut database) + .await + .expect("recoverable query"); + assert_eq!(stored, ("SELECT 'deep'".to_owned(), None, 0)); + database.close().await.expect("close copy"); + } + + #[tokio::test] + async fn a_copy_from_before_folders_still_trims_saved_queries() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let kept = save(&history, "kept", None).await; + let copy = root.path().join("legacy.sqlite3"); + let mut database = SqliteConnectOptions::new() + .filename(©) + .create_if_missing(true) + .connect() + .await + .expect("create legacy copy"); + sqlx::raw_sql(include_str!("../../migrations/20260914000000_create_history.sql")) + .execute(&mut database) + .await + .expect("legacy schema"); + for (id, name) in [(kept, "kept"), (kept + 1, "deleted")] { + sqlx::query( + "INSERT INTO saved_queries (id, name, query, connection_id, connection_name, created_at, updated_at) \ + VALUES (?, ?, 'SELECT 1', ?, 'local', 1, 1)", + ) + .bind(id) + .bind(name) + .bind(Uuid::nil().to_string()) + .execute(&mut database) + .await + .expect("legacy query"); + } + database.close().await.expect("close fixture"); + trim_copy(©, history.path.to_str().expect("UTF-8 path"), &[]) + .await + .expect("trim legacy copy"); + let mut database = copy_database(©).await; + let names: Vec = sqlx::query_scalar("SELECT name FROM saved_queries") + .fetch_all(&mut database) + .await + .expect("remaining queries"); + assert_eq!(names, ["kept"]); + database.close().await.expect("close copy"); + } +} diff --git a/core/crates/storage/src/query_history/favourites_migration_tests.rs b/core/crates/storage/src/query_history/favourites_migration_tests.rs new file mode 100644 index 0000000000..5f381e8fa4 --- /dev/null +++ b/core/crates/storage/src/query_history/favourites_migration_tests.rs @@ -0,0 +1,181 @@ +use super::*; +use crate::unix_time::from_unix; + +async fn old_database(root: &tempfile::TempDir, migrations: usize) -> (StoragePaths, SqlitePool) { + let paths = StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro"); + crate::fs::create_private_file_if_missing(&paths.history_database()).expect("file"); + let pool = SqlitePoolOptions::new() + .max_connections(1) + .connect_with( + SqliteConnectOptions::new() + .filename(paths.history_database()) + .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal), + ) + .await + .expect("pool"); + sqlx::migrate::Migrator::with_migrations(schema::MIGRATOR.iter().take(migrations).cloned().collect()) + .run(&pool) + .await + .expect("old migrations"); + (paths, pool) +} + +async fn insert_queries(pool: &SqlitePool, connection: Uuid, other: Uuid) { + for (id, owner, name) in [(42, connection, "z"), (9, connection, "A"), (51, other, "other")] { + sqlx::query( + "INSERT INTO saved_queries (id, name, query, connection_id, connection_name, created_at, updated_at) \ + VALUES (?, ?, 'SELECT 42', ?, 'Original connection', 11, 12)", + ) + .bind(id) + .bind(name) + .bind(owner.to_string()) + .execute(pool) + .await + .expect("saved query fixture"); + } +} + +async fn assert_copy_kept(paths: &StoragePaths, migrations: i64) -> sqlx::SqliteConnection { + let copies = crate::upgrade_copies::copies_blocking(&paths.history_database()).expect("copies"); + assert_eq!(copies.len(), 1); + let mut copy = SqliteConnectOptions::new() + .filename(&copies[0].path) + .read_only(true) + .connect() + .await + .expect("open copy"); + let applied: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM _sqlx_migrations") + .fetch_one(&mut copy) + .await + .expect("copy migration count"); + assert_eq!(applied, migrations); + let ids: Vec = sqlx::query_scalar("SELECT id FROM saved_queries ORDER BY id") + .fetch_all(&mut copy) + .await + .expect("copy queries"); + assert_eq!(ids, [9, 42, 51]); + copy +} + +#[tokio::test] +async fn original_schema_upgrade_preserves_queries_and_assigns_connection_scoped_order() { + let root = tempfile::tempdir().expect("tempdir"); + let (paths, pool) = old_database(&root, 1).await; + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + insert_queries(&pool, connection, other).await; + pool.close().await; + + let history = QueryHistory::open(&paths).await.expect("upgrade"); + let queries = history.saved_queries().list(Some(connection)).await.expect("queries"); + assert_eq!( + queries.iter().map(|query| (query.id, query.order)).collect::>(), + [(9, 0), (42, 1)] + ); + for query in &queries { + assert_eq!(query.query, "SELECT 42"); + assert_eq!(query.connection_name, "Original connection"); + assert_eq!(query.created_at, from_unix(11)); + assert_eq!(query.updated_at, from_unix(12)); + assert_eq!(query.keyword, None); + assert_eq!(query.folder_id, None); + } + let other = history + .saved_queries() + .list(Some(other)) + .await + .expect("other connection"); + assert_eq!(other.len(), 1); + assert_eq!((other[0].id, other[0].order), (51, 0)); + assert_copy_kept(&paths, 1).await.close().await.expect("close copy"); +} + +#[tokio::test] +async fn favorites_schema_upgrade_preserves_filing_and_metadata_and_normalizes_positions() { + let root = tempfile::tempdir().expect("tempdir"); + let (paths, pool) = old_database(&root, 2).await; + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + insert_queries(&pool, connection, other).await; + for (id, owner, name, parent, order) in [ + (1, connection, "Reports", None, 8), + (2, connection, "Archive", None, 2), + (3, connection, "Monthly", Some(1), 8), + (4, other, "Other", None, 8), + ] { + sqlx::query( + "INSERT INTO saved_query_folders (id, connection_id, name, parent_id, sort_order, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, 21, 22)", + ) + .bind(id) + .bind(owner.to_string()) + .bind(name) + .bind(parent) + .bind(order) + .execute(&pool) + .await + .expect("folder fixture"); + } + sqlx::query("UPDATE saved_queries SET folder_id = 3, keyword = 'daily', sort_order = 9 WHERE id = 42") + .execute(&pool) + .await + .expect("file query"); + sqlx::query("UPDATE saved_queries SET sort_order = 4 WHERE id <> 42") + .execute(&pool) + .await + .expect("root query orders"); + sqlx::query("INSERT INTO favourite_tables (connection_id, database, schema, name, created_at) VALUES (?, 'shop', 'public', 'orders', 31)") + .bind(connection.to_string()).execute(&pool).await.expect("table fixture"); + sqlx::query("INSERT INTO favourite_databases (connection_id, database, environment, created_at) VALUES (?, 'shop', 'production', 32)") + .bind(connection.to_string()).execute(&pool).await.expect("database fixture"); + pool.close().await; + + let history = QueryHistory::open(&paths).await.expect("upgrade"); + let snapshot = history.saved_queries().snapshot(connection).await.expect("snapshot"); + let filed = snapshot + .queries + .iter() + .find(|query| query.id == 42) + .expect("filed query"); + assert_eq!( + (filed.folder_id, filed.keyword.as_deref(), filed.order), + (Some(3), Some("daily"), 0) + ); + assert_eq!(filed.query, "SELECT 42"); + assert_eq!(filed.connection_name, "Original connection"); + assert_eq!(filed.created_at, from_unix(11)); + assert_eq!(filed.updated_at, from_unix(12)); + let root_query = snapshot.queries.iter().find(|query| query.id == 9).expect("root query"); + assert_eq!((root_query.folder_id, root_query.order), (None, 0)); + for (id, parent, order) in [(1, None, 1), (2, None, 0), (3, Some(1), 0)] { + let folder = snapshot.folders.iter().find(|folder| folder.id == id).expect("folder"); + assert_eq!((folder.parent_id, folder.order), (parent, order)); + assert_eq!(folder.created_at, from_unix(21)); + assert_eq!(folder.updated_at, from_unix(22)); + } + let other = history.saved_queries().snapshot(other).await.expect("other connection"); + assert_eq!((other.queries[0].id, other.queries[0].order), (51, 0)); + assert_eq!((other.folders[0].id, other.folders[0].order), (4, 0)); + assert_eq!( + history.favourites().tables(connection).await.expect("tables")[0].name, + "orders" + ); + assert_eq!( + history.favourites().databases(connection).await.expect("databases")[0].environment, + crate::DatabaseEnvironment::Production + ); + + let mut copy = assert_copy_kept(&paths, 2).await; + let original: (Option, Option, i64) = + sqlx::query_as("SELECT folder_id, keyword, sort_order FROM saved_queries WHERE id = 42") + .fetch_one(&mut copy) + .await + .expect("original query metadata"); + assert_eq!(original, (Some(3), Some("daily".to_owned()), 9)); + let original_order: i64 = sqlx::query_scalar("SELECT sort_order FROM saved_query_folders WHERE id = 1") + .fetch_one(&mut copy) + .await + .expect("original folder order"); + assert_eq!(original_order, 8); + copy.close().await.expect("close copy"); +} diff --git a/core/crates/storage/src/query_history/mod.rs b/core/crates/storage/src/query_history/mod.rs index 3d9a70309d..1694c91d89 100644 --- a/core/crates/storage/src/query_history/mod.rs +++ b/core/crates/storage/src/query_history/mod.rs @@ -1,5 +1,8 @@ +mod backup_folders; mod entry; mod export; +#[cfg(test)] +mod favourites_migration_tests; mod history_connection; mod history_cursor; mod history_page; @@ -13,7 +16,9 @@ mod search_fold; mod status_filter; use std::path::{Path, PathBuf}; +use std::sync::Arc; use std::time::SystemTime; +use tokio::sync::watch; use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions}; use sqlx::{AssertSqlSafe, ConnectOptions, Connection, Row, SqlitePool}; @@ -63,6 +68,7 @@ pub(crate) enum Bind { pub struct QueryHistory { pool: SqlitePool, path: PathBuf, + saved_changes: Arc>, } impl QueryHistory { @@ -87,7 +93,11 @@ impl QueryHistory { crate::upgrade_copies::keep_database(&pool, &path, version).await?; } schema::migrate(&pool).await?; - Ok(Self { pool, path }) + Ok(Self { + pool, + path, + saved_changes: Arc::new(watch::channel(0).0), + }) } pub fn path(&self) -> &Path { @@ -98,17 +108,17 @@ impl QueryHistory { /// migration chain, one open: what the user keeps and what they /// ran are the same kind of thing in the same place. pub fn saved_queries(&self) -> crate::saved_queries::SavedQueries { - crate::saved_queries::SavedQueries::new(self.pool.clone(), self.path.clone()) + crate::saved_queries::SavedQueries::new(self.pool.clone(), self.path.clone(), self.saved_changes.clone()) } /// The folders saved queries are filed in, in the same database. pub fn saved_query_folders(&self) -> crate::saved_queries::SavedQueryFolders { - crate::saved_queries::SavedQueryFolders::new(self.pool.clone(), self.path.clone()) + crate::saved_queries::SavedQueryFolders::new(self.pool.clone(), self.path.clone(), self.saved_changes.clone()) } /// The favourite tables and databases, in the same database. pub fn favourites(&self) -> crate::favourites::Favourites { - crate::favourites::Favourites::new(self.pool.clone(), self.path.clone()) + crate::favourites::Favourites::new(self.pool.clone(), self.path.clone(), self.saved_changes.clone()) } pub async fn record(&self, entry: NewEntry) -> Result { @@ -268,8 +278,9 @@ impl QueryHistory { binds: chunk.iter().map(|id| Bind::Integer(*id)).collect(), }) .collect(); + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies(&self.path, &from_copies).await?; - let mut transaction = self.pool.begin().await?; let mut deleted = Vec::with_capacity(ids.len()); for chunk in ids.chunks(IDS_PER_STATEMENT) { let placeholders = vec!["?"; chunk.len()].join(","); @@ -323,6 +334,8 @@ impl QueryHistory { } pub async fn clear_all(&self) -> Result { + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies( &self.path, &[CopyDelete { @@ -333,15 +346,16 @@ impl QueryHistory { ) .await?; let affected = sqlx::query("DELETE FROM history") - .execute(&self.pool) + .execute(&mut *transaction) .await? .rows_affected(); // The delete triggers leave the queries' words in the index until it is optimized. if affected > 0 { sqlx::query("INSERT INTO history_search(history_search) VALUES('optimize')") - .execute(&self.pool) + .execute(&mut *transaction) .await?; } + transaction.commit().await?; Ok(affected as usize) } @@ -381,7 +395,10 @@ impl QueryHistory { .await?; } // Rows expired here, or unpinned since a copy was made, leave the copies too. + let mut database = self.pool.acquire().await?; + let transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies(&self.path, &[]).await?; + transaction.commit().await?; Ok(report) } @@ -397,6 +414,8 @@ impl QueryHistory { /// Drop every query run on a connection, pinned ones included, for a /// connection the user deleted along with its history. pub async fn delete_for_connection(&self, connection: Uuid) -> Result { + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies( &self.path, &[CopyDelete { @@ -408,16 +427,17 @@ impl QueryHistory { .await?; let removed = sqlx::query("DELETE FROM history WHERE connection_id = ?") .bind(connection.to_string()) - .execute(&self.pool) + .execute(&mut *transaction) .await? .rows_affected(); // As after a prune: the delete triggers leave tombstones in the // index until it is optimized. if removed > 0 { sqlx::query("INSERT INTO history_search(history_search) VALUES('optimize')") - .execute(&self.pool) + .execute(&mut *transaction) .await?; } + transaction.commit().await?; Ok(removed) } @@ -483,6 +503,7 @@ pub(crate) struct CopyDelete { pub(crate) binds: Vec, } +// Callers hold the live SQLite write lock until their deletion commits, so copy reconciliation cannot restore a pending deletion. pub(crate) async fn trim_upgrade_copies(path: &Path, first: &[CopyDelete]) -> Result<(), StorageError> { crate::upgrade_copies::remove_leftovers_blocking(path)?; let copies = crate::upgrade_copies::copies_blocking(path)?; @@ -521,6 +542,7 @@ fn is_busy(error: &StorageError) -> bool { async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), StorageError> { let mut database = SqliteConnectOptions::new() .filename(copy) + .foreign_keys(false) .journal_mode(sqlx::sqlite::SqliteJournalMode::Delete) .pragma("secure_delete", "ON") .disable_statement_logging() @@ -531,6 +553,7 @@ async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), .execute(&mut database) .await?; let mut transaction = database.begin().await?; + let has_folders = backup_folders::reconcile(&mut transaction).await?; for delete in first { let present: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM main.sqlite_master WHERE type = 'table' AND name = ?") @@ -564,9 +587,19 @@ async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), .await?; } } - // Every time, which costs little on an index already merged. + if has_folders { + backup_folders::repair_queries(&mut transaction).await?; + } + if sqlx::query("PRAGMA main.foreign_key_check") + .fetch_optional(&mut *transaction) + .await? + .is_some() + { + return Err(StorageError::Schema("invalid references in an upgrade copy".to_owned())); + } optimize_full_text_indexes(&mut transaction).await?; transaction.commit().await?; + sqlx::query("PRAGMA foreign_keys = ON").execute(&mut database).await?; sqlx::query("DETACH DATABASE live").execute(&mut database).await?; database.close().await?; Ok(()) @@ -719,7 +752,7 @@ mod tests { .fetch_one(&history.pool) .await .expect("count migrations"); - assert_eq!(applied, 2); + assert_eq!(applied, 3); } /// A database an earlier build wrote, with its saved queries, is kept @@ -913,7 +946,7 @@ mod tests { /// means a change went into a file that has already run somewhere. #[test] fn migrator_embeds_every_migration() { - assert_eq!(schema::MIGRATOR.iter().count(), 2); + assert_eq!(schema::MIGRATOR.iter().count(), 3); } #[tokio::test] diff --git a/core/crates/storage/src/saved_queries/deletion.rs b/core/crates/storage/src/saved_queries/deletion.rs new file mode 100644 index 0000000000..14c3b68e83 --- /dev/null +++ b/core/crates/storage/src/saved_queries/deletion.rs @@ -0,0 +1,160 @@ +use std::collections::{HashMap, HashSet}; +use std::path::Path; +use std::time::SystemTime; + +use sqlx::{AssertSqlSafe, Connection, Row, SqliteConnection, SqlitePool}; +use uuid::Uuid; + +use crate::StorageError; +use crate::query_history::{Bind, CopyDelete, trim_upgrade_copies}; +use crate::unix_time::to_unix; + +use super::ordering; + +pub(super) async fn delete_folder(pool: &SqlitePool, path: &Path, id: i64) -> Result<(), StorageError> { + let mut connection = pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, parent_id FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + let owner: String = row.try_get("connection_id")?; + let parent: Option = row.try_get("parent_id")?; + let ids: Vec = sqlx::query_scalar( + "WITH RECURSIVE subtree(id) AS (SELECT id FROM saved_query_folders WHERE id = ? \ + UNION SELECT f.id FROM saved_query_folders f JOIN subtree s ON f.parent_id = s.id) \ + SELECT id FROM subtree", + ) + .bind(id) + .fetch_all(&mut *transaction) + .await?; + let doomed: HashSet = ids.iter().copied().collect(); + trim_upgrade_copies(path, &folder_deletes(&ids)).await?; + let rows = sqlx::query( + "SELECT id, folder_id FROM saved_queries WHERE connection_id = ? AND folder_id IS NOT NULL \ + ORDER BY folder_id, sort_order, name COLLATE NOCASE, id", + ) + .bind(&owner) + .fetch_all(&mut *transaction) + .await?; + let mut position: i64 = sqlx::query_scalar( + "SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_queries WHERE connection_id = ? AND folder_id IS NULL", + ) + .bind(&owner) + .fetch_one(&mut *transaction) + .await?; + for row in rows { + if !doomed.contains(&row.try_get::("folder_id")?) { + continue; + } + sqlx::query("UPDATE saved_queries SET folder_id = NULL, sort_order = ?, updated_at = ? WHERE id = ?") + .bind(position) + .bind(to_unix(SystemTime::now())) + .bind(row.try_get::("id")?) + .execute(&mut *transaction) + .await?; + position += 1; + } + delete_folder_rows(&mut transaction, &doomed).await?; + ordering::compact_folders(&mut transaction, &owner, parent).await?; + transaction.commit().await?; + Ok(()) +} + +pub(super) async fn delete_connection( + pool: &SqlitePool, + path: &Path, + connection: Uuid, +) -> Result<(usize, bool), StorageError> { + let mut database = pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let owner = connection.to_string(); + let copies = [ + "saved_queries", + "saved_query_folders", + "favourite_tables", + "favourite_databases", + ] + .map(|table| CopyDelete { + table, + sql: format!("DELETE FROM main.{table} WHERE connection_id = ?"), + binds: vec![Bind::Text(owner.clone())], + }); + trim_upgrade_copies(path, &copies).await?; + let queries = sqlx::query("DELETE FROM saved_queries WHERE connection_id = ?") + .bind(&owner) + .execute(&mut *transaction) + .await? + .rows_affected(); + let folders: Vec = sqlx::query_scalar("SELECT id FROM saved_query_folders WHERE connection_id = ?") + .bind(&owner) + .fetch_all(&mut *transaction) + .await?; + let mut changed = queries > 0 || !folders.is_empty(); + delete_folder_rows(&mut transaction, &folders.into_iter().collect()).await?; + for statement in [ + "DELETE FROM favourite_tables WHERE connection_id = ?", + "DELETE FROM favourite_databases WHERE connection_id = ?", + ] { + changed |= sqlx::query(statement) + .bind(&owner) + .execute(&mut *transaction) + .await? + .rows_affected() + > 0; + } + transaction.commit().await?; + Ok((queries as usize, changed)) +} + +fn folder_deletes(ids: &[i64]) -> Vec { + ids.chunks(500) + .map(|chunk| CopyDelete { + table: "saved_query_folders", + sql: format!( + "DELETE FROM main.saved_query_folders WHERE id IN ({})", + vec!["?"; chunk.len()].join(",") + ), + binds: chunk.iter().map(|id| Bind::Integer(*id)).collect(), + }) + .collect() +} + +async fn delete_folder_rows(database: &mut SqliteConnection, ids: &HashSet) -> Result<(), StorageError> { + // Deleting leaves first avoids SQLite's cascade depth limit without moving names into occupied sibling lists. + let rows: Vec<(i64, Option)> = sqlx::query_as("SELECT id, parent_id FROM saved_query_folders") + .fetch_all(&mut *database) + .await?; + let parents: HashMap> = rows.into_iter().filter(|(id, _)| ids.contains(id)).collect(); + let mut children: HashMap = parents.keys().map(|id| (*id, 0)).collect(); + for parent in parents.values().flatten() { + if let Some(count) = children.get_mut(parent) { + *count += 1; + } + } + let mut leaves: Vec = children + .iter() + .filter_map(|(id, count)| (*count == 0).then_some(*id)) + .collect(); + let mut removed = 0; + while let Some(id) = leaves.pop() { + sqlx::query("DELETE FROM saved_query_folders WHERE id = ?") + .bind(id) + .execute(&mut *database) + .await?; + removed += 1; + if let Some(Some(parent)) = parents.get(&id) + && let Some(count) = children.get_mut(parent) + { + *count -= 1; + if *count == 0 { + leaves.push(*parent); + } + } + } + if removed != parents.len() { + return Err(StorageError::Schema("saved query folder cycle".to_owned())); + } + Ok(()) +} diff --git a/core/crates/storage/src/saved_queries/folders.rs b/core/crates/storage/src/saved_queries/folders.rs index aac5e55f6e..c682502a62 100644 --- a/core/crates/storage/src/saved_queries/folders.rs +++ b/core/crates/storage/src/saved_queries/folders.rs @@ -1,58 +1,57 @@ +use std::collections::HashSet; use std::path::PathBuf; +use std::sync::Arc; use std::time::SystemTime; -use sqlx::{Row, SqlitePool}; +use sqlx::{AssertSqlSafe, Connection, Row, SqliteConnection, SqlitePool}; +use tokio::sync::watch; use uuid::Uuid; use crate::error::StorageError; +use crate::name_rules::{self, NameFault}; use crate::unix_time::{from_unix, to_unix}; -/// A folder of a connection's saved queries, which can hold others. #[derive(Debug, Clone, PartialEq, Eq)] pub struct SavedQueryFolder { pub id: i64, pub connection_id: Uuid, pub name: String, - /// The folder it sits in, none at the top of the connection's list. pub parent_id: Option, - /// Its place among the folders of its parent. pub order: i64, pub created_at: SystemTime, pub updated_at: SystemTime, } -/// A name long enough to be unreadable in the list is a name nobody -/// meant to type, as for a saved query. const MAX_NAME_CHARS: usize = 200; -/// The folders saved queries are filed in. Cloning shares the pool with -/// the history it lives beside. #[derive(Debug, Clone)] pub struct SavedQueryFolders { pool: SqlitePool, - // The database's file, whose upgrade copies a delete reaches too. path: PathBuf, + changes: Arc>, } impl SavedQueryFolders { - pub(crate) fn new(pool: SqlitePool, path: PathBuf) -> Self { - Self { pool, path } + pub(crate) fn new(pool: SqlitePool, path: PathBuf, changes: Arc>) -> Self { + Self { pool, path, changes } + } + + pub fn changes(&self) -> watch::Receiver { + self.changes.subscribe() + } + + fn changed(&self) { + self.changes + .send_modify(|revision| *revision = revision.wrapping_add(1)); } - /// Make a folder in `parent`, none for the top, last among its - /// siblings. The parent must be the same connection's. pub async fn create(&self, connection: Uuid, name: &str, parent: Option) -> Result { let name = checked_name(name)?; - if let Some(parent) = parent { - let owner: Option = - sqlx::query_scalar("SELECT connection_id FROM saved_query_folders WHERE id = ?") - .bind(parent) - .fetch_optional(&self.pool) - .await?; - if owner.as_deref() != Some(connection.to_string().as_str()) { - return Err(StorageError::NotFound); - } - } + let owner = connection.to_string(); + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + check_parent(&mut transaction, &owner, parent, None).await?; + check_name(&mut transaction, &owner, parent, &name, None).await?; let now = to_unix(SystemTime::now()); let id = sqlx::query( "INSERT INTO saved_query_folders (connection_id, name, parent_id, sort_order, created_at, updated_at) \ @@ -61,59 +60,61 @@ impl SavedQueryFolders { WHERE connection_id = ?1 AND parent_id IS ?3), ?4, ?4) \ RETURNING id", ) - .bind(connection.to_string()) + .bind(owner) .bind(name) .bind(parent) .bind(now) - .fetch_one(&self.pool) + .fetch_one(&mut *transaction) .await .map_err(name_taken)? .try_get("id")?; + transaction.commit().await?; + self.changed(); Ok(id) } pub async fn rename(&self, id: i64, name: &str) -> Result<(), StorageError> { let name = checked_name(name)?; - let affected = sqlx::query("UPDATE saved_query_folders SET name = ?, updated_at = ? WHERE id = ?") + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let (owner, parent, previous): (String, Option, String) = + sqlx::query_as("SELECT connection_id, parent_id, name FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + if previous == name { + transaction.commit().await?; + return Ok(()); + } + check_name(&mut transaction, &owner, parent, &name, Some(id)).await?; + sqlx::query("UPDATE saved_query_folders SET name = ?, updated_at = ? WHERE id = ?") .bind(name) .bind(to_unix(SystemTime::now())) .bind(id) - .execute(&self.pool) + .execute(&mut *transaction) .await - .map_err(name_taken)? - .rows_affected(); - match affected { - 0 => Err(StorageError::NotFound), - _ => Ok(()), - } + .map_err(name_taken)?; + transaction.commit().await?; + self.changed(); + Ok(()) } - /// Move a folder into `parent`, none for the top, last among the - /// folders there. A folder never goes inside itself or inside one it - /// holds. pub async fn move_to(&self, id: i64, parent: Option) -> Result<(), StorageError> { - let mut transaction = self.pool.begin().await?; - let connection: Option = - sqlx::query_scalar("SELECT connection_id FROM saved_query_folders WHERE id = ?") + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let (owner, previous, name): (String, Option, String) = + sqlx::query_as("SELECT connection_id, parent_id, name FROM saved_query_folders WHERE id = ?") .bind(id) .fetch_optional(&mut *transaction) - .await?; - let connection = connection.ok_or(StorageError::NotFound)?; - let mut above = parent; - while let Some(held) = above { - if held == id { - return Err(StorageError::FolderCycle { id }); - } - let row = sqlx::query("SELECT connection_id, parent_id FROM saved_query_folders WHERE id = ?") - .bind(held) - .fetch_optional(&mut *transaction) .await? .ok_or(StorageError::NotFound)?; - if row.try_get::("connection_id")? != connection { - return Err(StorageError::NotFound); - } - above = row.try_get("parent_id")?; + check_parent(&mut transaction, &owner, parent, Some(id)).await?; + if previous == parent { + transaction.commit().await?; + return Ok(()); } + check_name(&mut transaction, &owner, parent, &name, Some(id)).await?; sqlx::query( "UPDATE saved_query_folders SET parent_id = ?1, updated_at = ?2, \ sort_order = (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_query_folders \ @@ -122,42 +123,23 @@ impl SavedQueryFolders { ) .bind(parent) .bind(to_unix(SystemTime::now())) - .bind(connection) + .bind(&owner) .bind(id) .execute(&mut *transaction) .await .map_err(name_taken)?; + super::ordering::compact_folders(&mut transaction, &owner, previous).await?; transaction.commit().await?; + self.changed(); Ok(()) } - /// Delete a folder and the folders in it. The queries filed in them - /// stay, at the top of the connection's list. pub async fn delete(&self, id: i64) -> Result<(), StorageError> { - // The folders in it go from the copies with it, by the cascade, and - // the copies' sweep of folders the database no longer has. - crate::query_history::trim_upgrade_copies( - &self.path, - &[crate::query_history::CopyDelete { - table: "saved_query_folders", - sql: "DELETE FROM main.saved_query_folders WHERE id = ?".to_owned(), - binds: vec![crate::query_history::Bind::Integer(id)], - }], - ) - .await?; - let affected = sqlx::query("DELETE FROM saved_query_folders WHERE id = ?") - .bind(id) - .execute(&self.pool) - .await? - .rows_affected(); - match affected { - 0 => Err(StorageError::NotFound), - _ => Ok(()), - } + super::deletion::delete_folder(&self.pool, &self.path, id).await?; + self.changed(); + Ok(()) } - /// Every folder of `connection`, the order a list shows them in: by - /// parent, then place, then name. pub async fn list(&self, connection: Uuid) -> Result, StorageError> { let rows = sqlx::query( "SELECT id, connection_id, name, parent_id, sort_order, created_at, updated_at \ @@ -167,28 +149,80 @@ impl SavedQueryFolders { .bind(connection.to_string()) .fetch_all(&self.pool) .await?; - rows.into_iter() - .map(|row| { - let owner: String = row.try_get("connection_id")?; - Ok(SavedQueryFolder { - id: row.try_get("id")?, - connection_id: Uuid::parse_str(&owner).unwrap_or_default(), - name: row.try_get("name")?, - parent_id: row.try_get("parent_id")?, - order: row.try_get("sort_order")?, - created_at: from_unix(row.try_get::("created_at")?), - updated_at: from_unix(row.try_get::("updated_at")?), - }) - }) - .collect() + rows.into_iter().map(row_to_folder).collect() } } -fn checked_name(name: &str) -> Result<&str, StorageError> { - let name = name.trim(); - if name.is_empty() { - return Err(StorageError::EmptyName); +async fn check_parent( + database: &mut SqliteConnection, + connection: &str, + parent: Option, + moving: Option, +) -> Result<(), StorageError> { + let mut above = parent; + let mut visited = HashSet::new(); + while let Some(id) = above { + if Some(id) == moving || !visited.insert(id) { + return Err(StorageError::FolderCycle { + id: moving.unwrap_or(id), + }); + } + let (owner, next): (String, Option) = + sqlx::query_as("SELECT connection_id, parent_id FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *database) + .await? + .ok_or(StorageError::NotFound)?; + if owner != connection { + return Err(StorageError::NotFound); + } + above = next; } + Ok(()) +} + +async fn check_name( + database: &mut SqliteConnection, + connection: &str, + parent: Option, + name: &str, + own_id: Option, +) -> Result<(), StorageError> { + let siblings: Vec<(i64, String)> = + sqlx::query_as("SELECT id, name FROM saved_query_folders WHERE connection_id = ? AND parent_id IS ?") + .bind(connection) + .bind(parent) + .fetch_all(database) + .await?; + let key = name_rules::shown(name).to_lowercase(); + if siblings + .into_iter() + .any(|(id, sibling)| Some(id) != own_id && name_rules::shown(&sibling).to_lowercase() == key) + { + return Err(StorageError::FolderNameTaken); + } + Ok(()) +} + +pub(super) fn row_to_folder(row: sqlx::sqlite::SqliteRow) -> Result { + let owner: String = row.try_get("connection_id")?; + let connection_id = Uuid::parse_str(&owner).map_err(|error| StorageError::Schema(error.to_string()))?; + Ok(SavedQueryFolder { + id: row.try_get("id")?, + connection_id, + name: row.try_get("name")?, + parent_id: row.try_get("parent_id")?, + order: row.try_get("sort_order")?, + created_at: from_unix(row.try_get::("created_at")?), + updated_at: from_unix(row.try_get::("updated_at")?), + }) +} + +fn checked_name(name: &str) -> Result { + let name = name_rules::checked(name).map_err(|error| match error { + NameFault::Empty => StorageError::EmptyName, + NameFault::ControlCharacter => StorageError::FolderNameInvalid, + })?; if name.chars().count() > MAX_NAME_CHARS { return Err(StorageError::TooLarge { got: name.chars().count(), @@ -204,3 +238,7 @@ fn name_taken(error: sqlx::Error) -> StorageError { _ => StorageError::Database(error), } } + +#[cfg(test)] +#[path = "folders_tests.rs"] +mod tests; diff --git a/core/crates/storage/src/saved_queries/folders_tests.rs b/core/crates/storage/src/saved_queries/folders_tests.rs new file mode 100644 index 0000000000..71c91f6af7 --- /dev/null +++ b/core/crates/storage/src/saved_queries/folders_tests.rs @@ -0,0 +1,273 @@ +use super::*; +use crate::paths::StoragePaths; +use crate::query_history::QueryHistory; + +async fn history(root: &tempfile::TempDir) -> QueryHistory { + let paths = StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro"); + QueryHistory::open(&paths).await.expect("open history") +} + +fn places(folders: &[SavedQueryFolder], parent: Option) -> Vec<(i64, i64)> { + folders + .iter() + .filter(|folder| folder.parent_id == parent) + .map(|folder| (folder.id, folder.order)) + .collect() +} + +#[tokio::test] +async fn folder_names_are_visible_normalized_and_unique_within_their_parent() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let reports = folders + .create(connection, " E\u{301}tat\u{200b} ", None) + .await + .expect("normalized folder"); + assert_eq!(folders.list(connection).await.expect("list")[0].name, "État"); + assert!(matches!( + folders.create(connection, "état", None).await, + Err(StorageError::FolderNameTaken) + )); + folders + .create(connection, "état", Some(reports)) + .await + .expect("same name in another parent"); + folders + .create(Uuid::new_v4(), "état", None) + .await + .expect("same name on another connection"); + for name in ["", " \t ", "\u{200b}"] { + assert!(matches!( + folders.create(connection, name, None).await, + Err(StorageError::EmptyName) + )); + } + assert!(matches!( + folders.create(connection, "bad\nname", None).await, + Err(StorageError::FolderNameInvalid) + )); + assert!(matches!( + folders.create(connection, &"é".repeat(201), None).await, + Err(StorageError::TooLarge { got: 201, limit: 200 }) + )); + folders + .create(connection, &"e\u{301}".repeat(200), None) + .await + .expect("length applies to the normalized name"); +} + +#[tokio::test] +async fn independent_handles_cannot_create_unicode_name_duplicates() { + let root = tempfile::tempdir().expect("tempdir"); + let first_history = history(&root).await; + let second_history = history(&root).await; + let first = first_history.saved_query_folders(); + let second = second_history.saved_query_folders(); + let connection = Uuid::new_v4(); + let results = tokio::join!( + first.create(connection, "État", None), + second.create(connection, "e\u{301}tat", None) + ); + assert!(matches!( + results, + (Ok(_), Err(StorageError::FolderNameTaken)) | (Err(StorageError::FolderNameTaken), Ok(_)) + )); + let saved = first.list(connection).await.expect("list"); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].order, 0); +} + +#[tokio::test] +async fn independent_renames_cannot_claim_the_same_unicode_name() { + let root = tempfile::tempdir().expect("tempdir"); + let first_history = history(&root).await; + let second_history = history(&root).await; + let first = first_history.saved_query_folders(); + let second = second_history.saved_query_folders(); + let connection = Uuid::new_v4(); + let a = first.create(connection, "A", None).await.expect("A"); + let b = first.create(connection, "B", None).await.expect("B"); + let results = tokio::join!(first.rename(a, "État"), second.rename(b, "état")); + assert!(matches!( + results, + (Ok(()), Err(StorageError::FolderNameTaken)) | (Err(StorageError::FolderNameTaken), Ok(())) + )); + assert_eq!(first.list(connection).await.expect("list").len(), 2); +} + +#[tokio::test] +async fn moving_a_folder_compacts_its_source_and_appends_to_its_destination() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let source = folders.create(connection, "Source", None).await.expect("source"); + let target = folders.create(connection, "Target", None).await.expect("target"); + let a = folders.create(connection, "A", Some(source)).await.expect("A"); + let b = folders.create(connection, "B", Some(source)).await.expect("B"); + let c = folders.create(connection, "C", Some(source)).await.expect("C"); + let x = folders.create(connection, "X", Some(target)).await.expect("X"); + let other = Uuid::new_v4(); + folders.create(other, "Other", None).await.expect("other"); + let elsewhere = folders.list(other).await.expect("other folders"); + + folders.move_to(b, Some(target)).await.expect("move"); + let saved = folders.list(connection).await.expect("list"); + assert_eq!(places(&saved, Some(source)), vec![(a, 0), (c, 1)]); + assert_eq!(places(&saved, Some(target)), vec![(x, 0), (b, 1)]); + assert_eq!(folders.list(other).await.expect("other folders"), elsewhere); + folders.move_to(a, None).await.expect("move to root"); + let saved = folders.list(connection).await.expect("list"); + assert_eq!(places(&saved, None), vec![(source, 0), (target, 1), (a, 2)]); + assert_eq!(places(&saved, Some(source)), vec![(c, 0)]); +} + +#[tokio::test] +async fn invalid_moves_leave_names_hierarchy_and_positions_unchanged() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let parent = folders.create(connection, "Parent", None).await.expect("parent"); + let child = folders.create(connection, "État", Some(parent)).await.expect("child"); + folders + .create(connection, "état", None) + .await + .expect("same name at root"); + let foreign = folders.create(Uuid::new_v4(), "Foreign", None).await.expect("foreign"); + let before = folders.list(connection).await.expect("before"); + + assert!(matches!( + folders.move_to(child, None).await, + Err(StorageError::FolderNameTaken) + )); + assert!(matches!( + folders.move_to(child, Some(foreign)).await, + Err(StorageError::NotFound) + )); + assert!( + matches!(folders.move_to(parent, Some(child)).await, Err(StorageError::FolderCycle { id }) if id == parent) + ); + assert!( + matches!(folders.move_to(parent, Some(parent)).await, Err(StorageError::FolderCycle { id }) if id == parent) + ); + assert!(matches!( + folders.move_to(parent, Some(i64::MAX)).await, + Err(StorageError::NotFound) + )); + assert!(matches!( + folders.move_to(i64::MAX, None).await, + Err(StorageError::NotFound) + )); + assert_eq!(folders.list(connection).await.expect("after"), before); +} + +#[tokio::test] +async fn a_corrupt_ancestor_cycle_is_rejected_instead_of_walked_forever() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let a = folders.create(connection, "A", None).await.expect("A"); + let b = folders.create(connection, "B", Some(a)).await.expect("B"); + let c = folders.create(connection, "C", None).await.expect("C"); + sqlx::query("UPDATE saved_query_folders SET parent_id = ? WHERE id = ?") + .bind(b) + .bind(a) + .execute(&folders.pool) + .await + .expect("corrupt cycle"); + + assert!(matches!(folders.move_to(c, Some(a)).await, Err(StorageError::FolderCycle { id }) if id == c)); + assert!(matches!( + folders.create(connection, "D", Some(a)).await, + Err(StorageError::FolderCycle { .. }) + )); +} + +#[tokio::test] +async fn folder_notifications_follow_committed_changes_only() { + let root = tempfile::tempdir().expect("tempdir"); + let first_history = history(&root).await; + let second_history = history(&root).await; + let folders = first_history.saved_query_folders(); + let queries = first_history.saved_queries(); + let mut changes = queries.changes(); + let mut folder_changes = folders.changes(); + let connection = Uuid::new_v4(); + let a = folders.create(connection, "A", None).await.expect("A"); + assert_eq!(*changes.borrow_and_update(), 1); + assert_eq!(*folder_changes.borrow_and_update(), 1); + assert_eq!( + second_history + .saved_query_folders() + .list(connection) + .await + .expect("committed")[0] + .id, + a + ); + + folders.rename(a, "B").await.expect("rename"); + assert_eq!(*changes.borrow_and_update(), 2); + assert_eq!( + second_history + .saved_query_folders() + .list(connection) + .await + .expect("committed")[0] + .name, + "B" + ); + folders.rename(a, " B ").await.expect("same normalized name"); + folders.move_to(a, None).await.expect("same parent"); + assert!(!changes.has_changed().expect("open sender")); + assert!(matches!(folders.rename(a, "").await, Err(StorageError::EmptyName))); + assert!(matches!( + folders.rename(i64::MAX, "C").await, + Err(StorageError::NotFound) + )); + assert!(!changes.has_changed().expect("open sender")); + + let parent = folders.create(connection, "Parent", None).await.expect("parent"); + changes.borrow_and_update(); + folders.move_to(a, Some(parent)).await.expect("move"); + assert_eq!(*changes.borrow_and_update(), 4); + assert_eq!( + second_history + .saved_query_folders() + .list(connection) + .await + .expect("committed") + .iter() + .find(|folder| folder.id == a) + .expect("A") + .parent_id, + Some(parent) + ); +} + +#[tokio::test] +async fn a_failed_database_write_emits_no_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let changes = folders.changes(); + let connection = Uuid::new_v4(); + sqlx::query( + "CREATE TRIGGER reject_folder BEFORE INSERT ON saved_query_folders \ + BEGIN SELECT RAISE(ABORT, 'test failure'); END", + ) + .execute(&folders.pool) + .await + .expect("failure trigger"); + + assert!(matches!( + folders.create(connection, "A", None).await, + Err(StorageError::Database(_)) + )); + assert!(!changes.has_changed().expect("open sender")); + assert!(folders.list(connection).await.expect("list").is_empty()); +} diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index ecfc9fa358..2267928308 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -1,10 +1,17 @@ +mod deletion; mod folders; mod new_saved_query; +mod ordering; +#[cfg(test)] +mod ordering_tests; mod saved_query; +use std::sync::Arc; use std::time::SystemTime; -use sqlx::{Row, SqlitePool}; +use sqlx::{AssertSqlSafe, Connection, Row, SqlitePool}; +use tokio::sync::watch; +use unicode_normalization::UnicodeNormalization; use uuid::Uuid; use crate::error::StorageError; @@ -14,151 +21,96 @@ pub use folders::{SavedQueryFolder, SavedQueryFolders}; pub use new_saved_query::NewSavedQuery; pub use saved_query::SavedQuery; -/// The columns a saved query is read from, in one place so a read and its -/// row mapping cannot drift. macro_rules! columns { () => { "id, name, query, connection_id, connection_name, keyword, folder_id, sort_order, created_at, updated_at" }; } -/// The longest keyword, which is typed to expand. const MAX_KEYWORD_CHARS: usize = 64; +const MAX_QUERY_BYTES: usize = 1024 * 1024; +const MAX_NAME_CHARS: usize = 200; -/// What a save did, so the caller can say which. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SaveOutcome { pub id: i64, - /// The name was already in use on this connection and its query - /// was overwritten. pub replaced: bool, } -/// The cap the query history puts on one entry, applied here too: a -/// saved query is the same kind of text and the same reasons apply. -const MAX_QUERY_BYTES: usize = 1024 * 1024; - -/// A name long enough to be unreadable in the list is a name nobody -/// meant to type. -const MAX_NAME_CHARS: usize = 200; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SavedQueriesSnapshot { + pub queries: Vec, + pub folders: Vec, +} -/// The user's named queries. Cloning shares the pool with the query -/// history it lives beside. #[derive(Debug, Clone)] pub struct SavedQueries { pool: SqlitePool, - // The database's file, whose upgrade copies a delete reaches too. path: std::path::PathBuf, + changes: Arc>, } impl SavedQueries { - pub(crate) fn new(pool: SqlitePool, path: std::path::PathBuf) -> Self { - Self { pool, path } + pub(crate) fn new(pool: SqlitePool, path: std::path::PathBuf, changes: Arc>) -> Self { + Self { pool, path, changes } + } + + pub fn changes(&self) -> watch::Receiver { + self.changes.subscribe() + } + + fn changed(&self) { + self.changes + .send_modify(|revision| *revision = revision.wrapping_add(1)); } - /// Keep `query` under its name, replacing whatever that name held - /// for this connection. - /// - /// Saving under a name already in use overwrites it, because that - /// is what the user is asking for: the same report, fixed. The - /// caller is expected to have confirmed the overwrite, which it - /// can see coming from `list`. pub async fn save(&self, query: NewSavedQuery) -> Result { - let name = query.name.trim(); - if name.is_empty() { - return Err(StorageError::EmptyName); - } - if name.chars().count() > MAX_NAME_CHARS { - return Err(StorageError::TooLarge { - got: name.chars().count(), - limit: MAX_NAME_CHARS, - }); - } - if query.query.len() > MAX_QUERY_BYTES { - return Err(StorageError::TooLarge { - got: query.query.len(), - limit: MAX_QUERY_BYTES, - }); - } - let now = to_unix(SystemTime::now()); - // Asked before the write, because afterwards there is no way to - // tell an insert from an overwrite: only one connection is ever - // open on this pool, so nothing can slip in between. + let name = checked_query(&query)?; + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; let replaced: bool = sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM saved_queries WHERE connection_id = ? AND name = ?") .bind(query.connection_id.to_string()) .bind(name) - .fetch_one(&self.pool) + .fetch_one(&mut *transaction) .await? > 0; - let id = sqlx::query( - r#" - INSERT INTO saved_queries (name, query, connection_id, connection_name, created_at, updated_at) - VALUES (?, ?, ?, ?, ?, ?) - ON CONFLICT (connection_id, name) DO UPDATE SET - query = excluded.query, - connection_name = excluded.connection_name, - updated_at = excluded.updated_at - RETURNING id - "#, + let now = to_unix(SystemTime::now()); + let id = sqlx::query_scalar( + "INSERT INTO saved_queries (name, query, connection_id, connection_name, sort_order, created_at, updated_at) \ + VALUES (?1, ?2, ?3, ?4, \ + (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_queries WHERE connection_id = ?3 AND folder_id IS NULL), ?5, ?5) \ + ON CONFLICT (connection_id, name) DO UPDATE SET query = excluded.query, \ + connection_name = excluded.connection_name, updated_at = excluded.updated_at RETURNING id", ) - .bind(name) - .bind(&query.query) - .bind(query.connection_id.to_string()) - .bind(&query.connection_name) - .bind(now) - .bind(now) - .fetch_one(&self.pool) - .await? - .try_get("id")?; + .bind(name).bind(&query.query).bind(query.connection_id.to_string()) + .bind(&query.connection_name).bind(now) + .fetch_one(&mut *transaction).await?; + transaction.commit().await?; + self.changed(); Ok(SaveOutcome { id, replaced }) } - // An import never overwrites what the user saved, even when another window saves the same - // name between the import's look and its write. `None` when the name is taken. pub async fn save_if_new(&self, query: NewSavedQuery) -> Result, StorageError> { - let name = query.name.trim(); - if name.is_empty() { - return Err(StorageError::EmptyName); - } - if name.chars().count() > MAX_NAME_CHARS { - return Err(StorageError::TooLarge { - got: name.chars().count(), - limit: MAX_NAME_CHARS, - }); - } - if query.query.len() > MAX_QUERY_BYTES { - return Err(StorageError::TooLarge { - got: query.query.len(), - limit: MAX_QUERY_BYTES, - }); - } - let now = to_unix(SystemTime::now()); - let inserted = sqlx::query( - r#" - INSERT INTO saved_queries (name, query, connection_id, connection_name, created_at, updated_at) - VALUES (?, ?, ?, ?, ?, ?) - ON CONFLICT (connection_id, name) DO NOTHING - RETURNING id - "#, + let name = checked_query(&query)?; + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let id = sqlx::query_scalar( + "INSERT INTO saved_queries (name, query, connection_id, connection_name, sort_order, created_at, updated_at) \ + VALUES (?1, ?2, ?3, ?4, \ + (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_queries WHERE connection_id = ?3 AND folder_id IS NULL), ?5, ?5) \ + ON CONFLICT (connection_id, name) DO NOTHING RETURNING id", ) - .bind(name) - .bind(&query.query) - .bind(query.connection_id.to_string()) - .bind(&query.connection_name) - .bind(now) - .bind(now) - .fetch_optional(&self.pool) - .await?; - Ok(match inserted { - Some(row) => Some(row.try_get("id")?), - None => None, - }) + .bind(name).bind(&query.query).bind(query.connection_id.to_string()) + .bind(&query.connection_name).bind(to_unix(SystemTime::now())) + .fetch_optional(&mut *transaction).await?; + transaction.commit().await?; + if id.is_some() { + self.changed(); + } + Ok(id) } - /// Everything saved against `connection`, or everything at all when - /// no connection is given. Ordered by name, because the user - /// looking for one knows what they called it. pub async fn list(&self, connection: Option) -> Result, StorageError> { let rows = match connection { Some(id) => { @@ -184,122 +136,195 @@ impl SavedQueries { rows.into_iter().map(row_to_saved_query).collect() } + pub async fn snapshot(&self, connection: Uuid) -> Result { + let mut transaction = self.pool.begin().await?; + let queries = sqlx::query(concat!( + "SELECT ", + columns!(), + " FROM saved_queries WHERE connection_id = ? ORDER BY sort_order, name COLLATE NOCASE, id" + )) + .bind(connection.to_string()) + .fetch_all(&mut *transaction) + .await? + .into_iter() + .map(row_to_saved_query) + .collect::, _>>()?; + let folders = sqlx::query( + "SELECT id, connection_id, name, parent_id, sort_order, created_at, updated_at \ + FROM saved_query_folders WHERE connection_id = ? ORDER BY sort_order, name COLLATE NOCASE, id", + ) + .bind(connection.to_string()) + .fetch_all(&mut *transaction) + .await? + .into_iter() + .map(folders::row_to_folder) + .collect::, _>>()?; + transaction.commit().await?; + Ok(SavedQueriesSnapshot { queries, folders }) + } + pub async fn get(&self, id: i64) -> Result, StorageError> { - let row = sqlx::query(concat!("SELECT ", columns!(), " FROM saved_queries WHERE id = ?")) + sqlx::query(concat!("SELECT ", columns!(), " FROM saved_queries WHERE id = ?")) .bind(id) .fetch_optional(&self.pool) - .await?; - row.map(row_to_saved_query).transpose() + .await? + .map(row_to_saved_query) + .transpose() } - /// Give a saved query a different name. Fails when the connection - /// already has one under that name, which is the caller's cue to - /// say so rather than silently merge two queries into one. pub async fn rename(&self, id: i64, name: &str) -> Result<(), StorageError> { - let name = name.trim(); - if name.is_empty() { - return Err(StorageError::EmptyName); - } - if name.chars().count() > MAX_NAME_CHARS { - return Err(StorageError::TooLarge { - got: name.chars().count(), - limit: MAX_NAME_CHARS, - }); + let name = checked_name(name)?; + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let previous: Option = sqlx::query_scalar("SELECT name FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await?; + let previous = previous.ok_or(StorageError::NotFound)?; + if previous == name { + return Ok(()); } - let affected = sqlx::query("UPDATE saved_queries SET name = ?, updated_at = ? WHERE id = ?") + sqlx::query("UPDATE saved_queries SET name = ?, updated_at = ? WHERE id = ?") .bind(name) .bind(to_unix(SystemTime::now())) .bind(id) - .execute(&self.pool) + .execute(&mut *transaction) .await .map_err(|error| match &error { sqlx::Error::Database(database) if database.is_unique_violation() => StorageError::NameTaken, _ => StorageError::Database(error), - })? - .rows_affected(); - match affected { - 0 => Err(StorageError::NotFound), - _ => Ok(()), - } + })?; + transaction.commit().await?; + self.changed(); + Ok(()) } - /// Give a saved query the word that expands to it in the editor, or - /// none. A word is one run of characters with no whitespace, kept as - /// typed; two queries of a connection never share one in any case. pub async fn set_keyword(&self, id: i64, keyword: Option<&str>) -> Result<(), StorageError> { - let keyword = keyword.map(str::trim).filter(|word| !word.is_empty()); - if let Some(word) = keyword - && (word.chars().count() > MAX_KEYWORD_CHARS || word.chars().any(|c| c.is_whitespace() || c.is_control())) + let keyword: Option = keyword + .map(str::trim) + .filter(|word| !word.is_empty()) + .map(|word| word.nfc().collect()); + if let Some(word) = &keyword + && (word.chars().count() > MAX_KEYWORD_CHARS + || word.chars().any(|c| { + c.is_whitespace() || c.is_control() || tablepro_core::unicode_blank::is_default_ignorable(c) + })) { return Err(StorageError::KeywordInvalid { max: MAX_KEYWORD_CHARS }); } - let affected = sqlx::query("UPDATE saved_queries SET keyword = ?, updated_at = ? WHERE id = ?") + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, keyword FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + let owner: String = row.try_get("connection_id")?; + if row.try_get::, _>("keyword")? == keyword { + return Ok(()); + } + if let Some(word) = &keyword { + let held: Vec = sqlx::query_scalar( + "SELECT keyword FROM saved_queries WHERE connection_id = ? AND id <> ? AND keyword IS NOT NULL", + ) + .bind(owner) + .bind(id) + .fetch_all(&mut *transaction) + .await?; + let key = word.to_lowercase(); + if held + .iter() + .any(|held| held.nfc().collect::().to_lowercase() == key) + { + return Err(StorageError::KeywordTaken); + } + } + sqlx::query("UPDATE saved_queries SET keyword = ?, updated_at = ? WHERE id = ?") .bind(keyword) .bind(to_unix(SystemTime::now())) .bind(id) - .execute(&self.pool) + .execute(&mut *transaction) .await .map_err(|error| match &error { sqlx::Error::Database(database) if database.is_unique_violation() => StorageError::KeywordTaken, _ => StorageError::Database(error), - })? - .rows_affected(); - match affected { - 0 => Err(StorageError::NotFound), - _ => Ok(()), - } + })?; + transaction.commit().await?; + self.changed(); + Ok(()) } - /// File a saved query in `folder`, none for the top, before another - /// query of that place or last. The folder must be the same - /// connection's. The places of the queries there are numbered from 0 - /// again, so the order is whole. pub async fn move_to_folder(&self, id: i64, folder: Option, before: Option) -> Result<(), StorageError> { - let mut transaction = self.pool.begin().await?; - let connection: Option = sqlx::query_scalar("SELECT connection_id FROM saved_queries WHERE id = ?") + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, folder_id FROM saved_queries WHERE id = ?") .bind(id) .fetch_optional(&mut *transaction) - .await?; - let connection = connection.ok_or(StorageError::NotFound)?; + .await? + .ok_or(StorageError::NotFound)?; + let owner: String = row.try_get("connection_id")?; + let old_folder: Option = row.try_get("folder_id")?; if let Some(folder) = folder { - let owner: Option = + let target: Option = sqlx::query_scalar("SELECT connection_id FROM saved_query_folders WHERE id = ?") .bind(folder) .fetch_optional(&mut *transaction) .await?; - if owner.as_deref() != Some(connection.as_str()) { + if target.as_deref() != Some(owner.as_str()) { return Err(StorageError::NotFound); } } + if before == Some(id) { + return if old_folder == folder { + Ok(()) + } else { + Err(StorageError::NotFound) + }; + } let mut place: Vec = sqlx::query_scalar( - "SELECT id FROM saved_queries WHERE folder_id IS ? AND id <> ? ORDER BY sort_order, name COLLATE NOCASE, id", + "SELECT id FROM saved_queries WHERE connection_id = ? AND folder_id IS ? \ + ORDER BY sort_order, name COLLATE NOCASE, id", ) + .bind(&owner) .bind(folder) - .bind(id) .fetch_all(&mut *transaction) .await?; - let at = before - .and_then(|before| place.iter().position(|held| *held == before)) - .unwrap_or(place.len()); + let original = place.clone(); + place.retain(|held| *held != id); + let at = match before { + Some(before) => place + .iter() + .position(|held| *held == before) + .ok_or(StorageError::NotFound)?, + None => place.len(), + }; place.insert(at, id); + if old_folder == folder && place == original { + return Ok(()); + } sqlx::query("UPDATE saved_queries SET folder_id = ?, updated_at = ? WHERE id = ?") .bind(folder) .bind(to_unix(SystemTime::now())) .bind(id) .execute(&mut *transaction) .await?; - for (order, held) in place.iter().enumerate() { - sqlx::query("UPDATE saved_queries SET sort_order = ? WHERE id = ?") - .bind(i64::try_from(order).unwrap_or(i64::MAX)) - .bind(held) - .execute(&mut *transaction) - .await?; + ordering::set_query_order(&mut transaction, &place).await?; + if old_folder != folder { + ordering::compact_queries(&mut transaction, &owner, old_folder).await?; } transaction.commit().await?; + self.changed(); Ok(()) } pub async fn delete(&self, id: i64) -> Result<(), StorageError> { + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, folder_id FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; crate::query_history::trim_upgrade_copies( &self.path, &[crate::query_history::CopyDelete { @@ -309,66 +334,53 @@ impl SavedQueries { }], ) .await?; - let affected = sqlx::query("DELETE FROM saved_queries WHERE id = ?") + sqlx::query("DELETE FROM saved_queries WHERE id = ?") .bind(id) - .execute(&self.pool) - .await? - .rows_affected(); - match affected { - 0 => Err(StorageError::NotFound), - _ => Ok(()), - } + .execute(&mut *transaction) + .await?; + ordering::compact_queries( + &mut transaction, + &row.try_get::("connection_id")?, + row.try_get("folder_id")?, + ) + .await?; + transaction.commit().await?; + self.changed(); + Ok(()) } - /// Drop everything saved against a connection, for when the - /// connection itself is removed. Its queries name tables only that - /// database has. pub async fn delete_for_connection(&self, connection: Uuid) -> Result { - // The copies an upgrade kept hold none of what the connection had. - let copies: Vec = [ - ( - "saved_queries", - "DELETE FROM main.saved_queries WHERE connection_id = ?", - ), - ( - "saved_query_folders", - "DELETE FROM main.saved_query_folders WHERE connection_id = ?", - ), - ( - "favourite_tables", - "DELETE FROM main.favourite_tables WHERE connection_id = ?", - ), - ( - "favourite_databases", - "DELETE FROM main.favourite_databases WHERE connection_id = ?", - ), - ] - .map(|(table, sql)| crate::query_history::CopyDelete { - table, - sql: sql.to_owned(), - binds: vec![crate::query_history::Bind::Text(connection.to_string())], - }) - .into(); - crate::query_history::trim_upgrade_copies(&self.path, &copies).await?; - let affected = sqlx::query("DELETE FROM saved_queries WHERE connection_id = ?") - .bind(connection.to_string()) - .execute(&self.pool) - .await? - .rows_affected(); - // What a connection's queries are filed under and the tables and - // databases marked beside them name only that connection's schema. - for statement in [ - "DELETE FROM saved_query_folders WHERE connection_id = ?", - "DELETE FROM favourite_tables WHERE connection_id = ?", - "DELETE FROM favourite_databases WHERE connection_id = ?", - ] { - sqlx::query(statement) - .bind(connection.to_string()) - .execute(&self.pool) - .await?; + let (queries, changed) = deletion::delete_connection(&self.pool, &self.path, connection).await?; + if changed { + self.changed(); } - Ok(affected as usize) + Ok(queries) + } +} + +fn checked_name(name: &str) -> Result<&str, StorageError> { + let name = name.trim(); + if name.is_empty() { + return Err(StorageError::EmptyName); + } + if name.chars().count() > MAX_NAME_CHARS { + return Err(StorageError::TooLarge { + got: name.chars().count(), + limit: MAX_NAME_CHARS, + }); + } + Ok(name) +} + +fn checked_query(query: &NewSavedQuery) -> Result<&str, StorageError> { + let name = checked_name(&query.name)?; + if query.query.len() > MAX_QUERY_BYTES { + return Err(StorageError::TooLarge { + got: query.query.len(), + limit: MAX_QUERY_BYTES, + }); } + Ok(name) } fn row_to_saved_query(row: sqlx::sqlite::SqliteRow) -> Result { @@ -377,7 +389,7 @@ fn row_to_saved_query(row: sqlx::sqlite::SqliteRow) -> Result Result<(), StorageError> { + for (order, id) in ids.iter().enumerate() { + sqlx::query("UPDATE saved_queries SET sort_order = ? WHERE id = ?") + .bind(order as i64) + .bind(id) + .execute(&mut *database) + .await?; + } + Ok(()) +} + +pub(super) async fn compact_queries( + database: &mut SqliteConnection, + connection: &str, + folder: Option, +) -> Result<(), StorageError> { + let ids = sqlx::query_scalar( + "SELECT id FROM saved_queries WHERE connection_id = ? AND folder_id IS ? \ + ORDER BY sort_order, name COLLATE NOCASE, id", + ) + .bind(connection) + .bind(folder) + .fetch_all(&mut *database) + .await?; + set_query_order(database, &ids).await +} + +pub(super) async fn compact_folders( + database: &mut SqliteConnection, + connection: &str, + parent: Option, +) -> Result<(), StorageError> { + let ids: Vec = sqlx::query_scalar( + "SELECT id FROM saved_query_folders WHERE connection_id = ? AND parent_id IS ? \ + ORDER BY sort_order, name COLLATE NOCASE, id", + ) + .bind(connection) + .bind(parent) + .fetch_all(&mut *database) + .await?; + for (order, id) in ids.into_iter().enumerate() { + sqlx::query("UPDATE saved_query_folders SET sort_order = ? WHERE id = ?") + .bind(order as i64) + .bind(id) + .execute(&mut *database) + .await?; + } + Ok(()) +} diff --git a/core/crates/storage/src/saved_queries/ordering_tests.rs b/core/crates/storage/src/saved_queries/ordering_tests.rs new file mode 100644 index 0000000000..a23d3f811e --- /dev/null +++ b/core/crates/storage/src/saved_queries/ordering_tests.rs @@ -0,0 +1,296 @@ +use super::*; +use crate::{DatabaseEnvironment, FavouriteTable, QueryHistory, StoragePaths}; + +fn paths(root: &tempfile::TempDir) -> StoragePaths { + StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro") +} + +fn query(connection: Uuid, name: &str) -> NewSavedQuery { + NewSavedQuery { + name: name.to_owned(), + query: format!("SELECT '{name}'"), + connection_id: connection, + connection_name: "local".to_owned(), + } +} + +async fn save(store: &SavedQueries, connection: Uuid, name: &str) -> i64 { + store.save(query(connection, name)).await.expect("save").id +} + +async fn order(store: &SavedQueries, connection: Uuid, folder: Option) -> Vec { + let mut rows = store.list(Some(connection)).await.expect("list"); + rows.retain(|row| row.folder_id == folder); + rows.sort_by_key(|row| row.order); + assert_eq!( + rows.iter().map(|row| row.order).collect::>(), + (0..i64::try_from(rows.len()).expect("row count")).collect::>() + ); + rows.into_iter().map(|row| row.id).collect() +} + +#[tokio::test] +async fn new_saves_append_and_replacement_keeps_identity_and_filing() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let z = save(&store, connection, "z").await; + let a = store + .save_if_new(query(connection, "a")) + .await + .expect("import") + .expect("inserted"); + let m = save(&store, connection, "m").await; + assert_eq!(order(&store, connection, None).await, [z, a, m]); + assert_eq!( + store.save_if_new(query(connection, "a")).await.expect("repeat import"), + None + ); + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + store.move_to_folder(a, Some(folder), None).await.expect("file"); + store.set_keyword(a, Some("daily")).await.expect("keyword"); + let before = store.get(a).await.expect("get").expect("query"); + let mut replacement = query(connection, "a"); + replacement.query = "SELECT 42".to_owned(); + replacement.connection_name = "renamed connection".to_owned(); + let replaced = store.save(replacement).await.expect("replace"); + assert_eq!(replaced, SaveOutcome { id: a, replaced: true }); + let after = store.get(a).await.expect("get").expect("query"); + assert_eq!( + (after.id, after.keyword, after.folder_id, after.order, after.created_at), + ( + before.id, + before.keyword, + before.folder_id, + before.order, + before.created_at + ) + ); + assert_eq!(after.query, "SELECT 42"); + assert_eq!(after.connection_name, "renamed connection"); + let b = save(&store, connection, "b").await; + assert_eq!(order(&store, connection, None).await, [z, m, b]); + assert_eq!(order(&store, connection, Some(folder)).await, [a]); +} + +#[tokio::test] +async fn moving_and_deleting_queries_compacts_only_their_connection_and_place() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + let other_z = save(&store, other, "z").await; + let other_a = save(&store, other, "a").await; + let a = save(&store, connection, "a").await; + let b = save(&store, connection, "b").await; + let c = save(&store, connection, "c").await; + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + store.move_to_folder(b, Some(folder), None).await.expect("file b"); + assert_eq!(order(&store, connection, None).await, [a, c]); + store + .move_to_folder(c, Some(folder), Some(b)) + .await + .expect("file c before b"); + assert_eq!(order(&store, connection, Some(folder)).await, [c, b]); + store.move_to_folder(c, None, Some(a)).await.expect("move c to root"); + assert_eq!(order(&store, connection, None).await, [c, a]); + assert_eq!(order(&store, connection, Some(folder)).await, [b]); + assert_eq!(order(&store, other, None).await, [other_z, other_a]); + store.delete(c).await.expect("delete c"); + assert_eq!(order(&store, connection, None).await, [a]); + assert_eq!(order(&store, other, None).await, [other_z, other_a]); +} + +#[tokio::test] +async fn invalid_destinations_and_self_before_leave_rows_and_revisions_alone() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let a = save(&store, connection, "a").await; + let b = save(&store, connection, "b").await; + let other = save(&store, Uuid::new_v4(), "other").await; + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + let before = store.snapshot(connection).await.expect("snapshot"); + let changes = store.changes(); + store.move_to_folder(a, None, Some(a)).await.expect("self-before no-op"); + store.move_to_folder(b, None, None).await.expect("already last"); + for (destination, before) in [(None, other), (Some(folder), a), (None, i64::MAX)] { + assert!(matches!( + store.move_to_folder(a, destination, Some(before)).await, + Err(StorageError::NotFound) + )); + } + assert!(!changes.has_changed().expect("no revision")); + assert_eq!(store.snapshot(connection).await.expect("snapshot"), before); +} + +#[tokio::test] +async fn unicode_keywords_share_one_key_even_when_separate_handles_write_together() { + let root = tempfile::tempdir().expect("tempdir"); + let first = QueryHistory::open(&paths(&root)).await.expect("first handle"); + let second = QueryHistory::open(&paths(&root)).await.expect("second handle"); + let first = first.saved_queries(); + let second = second.saved_queries(); + let connection = Uuid::new_v4(); + let a = save(&first, connection, "a").await; + let b = save(&first, connection, "b").await; + let (left, right) = tokio::join!( + first.set_keyword(a, Some("État")), + second.set_keyword(b, Some("e\u{301}tat")) + ); + assert!(matches!( + (&left, &right), + (Ok(()), Err(StorageError::KeywordTaken)) | (Err(StorageError::KeywordTaken), Ok(())) + )); + let held = first.list(Some(connection)).await.expect("list"); + assert_eq!(held.iter().filter(|row| row.keyword.is_some()).count(), 1); + first.set_keyword(a, None).await.expect("clear"); + second.set_keyword(b, None).await.expect("clear"); + first.set_keyword(a, Some("e\u{301}tat")).await.expect("canonicalize"); + assert_eq!( + first.get(a).await.expect("get").expect("query").keyword.as_deref(), + Some("état") + ); + assert!(matches!( + second.set_keyword(b, Some("ÉTAT")).await, + Err(StorageError::KeywordTaken) + )); + let other = save(&second, Uuid::new_v4(), "other").await; + second.set_keyword(other, Some("ÉTAT")).await.expect("other connection"); +} + +#[tokio::test] +async fn snapshots_never_return_a_query_whose_folder_was_read_from_another_generation() { + let root = tempfile::tempdir().expect("tempdir"); + let writer = QueryHistory::open(&paths(&root)).await.expect("writer"); + let reader = QueryHistory::open(&paths(&root)).await.expect("reader"); + let connection = Uuid::new_v4(); + let id = save(&writer.saved_queries(), connection, "report").await; + let change = async { + for index in 0..40 { + let folder = writer + .saved_query_folders() + .create(connection, &format!("Folder {index}"), None) + .await + .expect("create"); + writer + .saved_queries() + .move_to_folder(id, Some(folder), None) + .await + .expect("file"); + writer.saved_query_folders().delete(folder).await.expect("delete"); + } + }; + let read = async { + for _ in 0..160 { + let snapshot = reader.saved_queries().snapshot(connection).await.expect("snapshot"); + assert_eq!(snapshot.queries.len(), 1); + for query in snapshot.queries { + assert!( + query + .folder_id + .is_none_or(|id| snapshot.folders.iter().any(|folder| folder.id == id)) + ); + } + } + }; + tokio::join!(change, read); +} + +#[tokio::test] +async fn mutation_notifications_are_shared_and_follow_successful_changes() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let id = save(&store, connection, "report").await; + let mut changes = store.changes(); + let mut folders_changed = history.saved_query_folders().changes(); + let mut catalog_changed = history.favourites().changes(); + store.set_keyword(id, Some("daily")).await.expect("keyword"); + assert!(changes.has_changed().expect("revision")); + assert!(folders_changed.has_changed().expect("shared revision")); + assert!(catalog_changed.has_changed().expect("shared revision")); + changes.borrow_and_update(); + folders_changed.borrow_and_update(); + catalog_changed.borrow_and_update(); + store.set_keyword(id, Some("daily")).await.expect("same keyword"); + store.rename(id, "report").await.expect("same name"); + assert_eq!( + store + .save_if_new(query(connection, "report")) + .await + .expect("same import"), + None + ); + assert!(matches!( + store.set_keyword(id, Some("two words")).await, + Err(StorageError::KeywordInvalid { .. }) + )); + assert!(!changes.has_changed().expect("no revision")); + assert!(!folders_changed.has_changed().expect("no shared revision")); + assert!(!catalog_changed.has_changed().expect("no shared revision")); +} + +#[tokio::test] +async fn a_failed_connection_purge_preserves_every_kind_of_favorite_and_its_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let folders = history.saved_query_folders(); + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let id = save(&store, connection, "report").await; + let folder = folders.create(connection, "Reports", None).await.expect("folder"); + store.move_to_folder(id, Some(folder), None).await.expect("file"); + let table = FavouriteTable { + connection_id: connection, + database: None, + schema: None, + name: "orders".to_owned(), + }; + favourites.add_table(&table).await.expect("table"); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Production) + .await + .expect("database"); + let before = store.snapshot(connection).await.expect("snapshot"); + sqlx::query( + "CREATE TRIGGER reject_purge BEFORE DELETE ON favourite_databases BEGIN SELECT RAISE(ABORT, 'denied'); END", + ) + .execute(&store.pool) + .await + .expect("install failure"); + let changes = store.changes(); + assert!(store.delete_for_connection(connection).await.is_err()); + assert_eq!(store.snapshot(connection).await.expect("snapshot"), before); + assert_eq!(favourites.tables(connection).await.expect("tables"), vec![table]); + assert_eq!(favourites.databases(connection).await.expect("databases").len(), 1); + assert!(!changes.has_changed().expect("no revision")); + sqlx::query("DROP TRIGGER reject_purge") + .execute(&store.pool) + .await + .expect("remove failure"); + assert_eq!(store.delete_for_connection(connection).await.expect("purge"), 1); + assert!(changes.has_changed().expect("revision")); + let after = store.snapshot(connection).await.expect("snapshot"); + assert!(after.queries.is_empty()); + assert!(after.folders.is_empty()); + assert!(favourites.tables(connection).await.expect("tables").is_empty()); + assert!(favourites.databases(connection).await.expect("databases").is_empty()); +} diff --git a/core/crates/storage/src/saved_queries/saved_query.rs b/core/crates/storage/src/saved_queries/saved_query.rs index 5cd70169d8..32c6f34d7e 100644 --- a/core/crates/storage/src/saved_queries/saved_query.rs +++ b/core/crates/storage/src/saved_queries/saved_query.rs @@ -2,32 +2,21 @@ use std::time::SystemTime; use uuid::Uuid; -/// One query the user named and kept. #[derive(Debug, Clone, PartialEq, Eq)] pub struct SavedQuery { pub id: i64, pub name: String, pub query: String, - /// The connection it was saved against. A saved query is written - /// for one database's schema, so it is listed under that - /// connection rather than offered everywhere. pub connection_id: Uuid, - /// The connection's name as of the last save, which is what the - /// list shows when the connection itself is gone. pub connection_name: String, - /// What the user types in the editor to get the query, one word, - /// unique among the connection's queries in any case. pub keyword: Option, - /// The folder it is filed in, none for the top of the connection's list. pub folder_id: Option, - /// Its place among the queries of its folder. pub order: i64, pub created_at: SystemTime, pub updated_at: SystemTime, } impl SavedQuery { - /// The first non-empty line, for a list row's subtitle. pub fn summary(&self) -> &str { self.query .lines() diff --git a/core/docs/decisions/0017-favourites.md b/core/docs/decisions/0017-favourites.md index e6488904f1..fc18d95755 100644 --- a/core/docs/decisions/0017-favourites.md +++ b/core/docs/decisions/0017-favourites.md @@ -9,21 +9,23 @@ The macOS sidebar has a Favorites scope next to Tables. It lists SQL favorites i ## Decision -The folders, the keywords, the order and the marked tables and databases live in the history's database, added by one migration, `20261108000000_favourites.sql`, and reached through `QueryHistory::saved_queries`, `saved_query_folders` and `favourites`. +The folders, the keywords, the order and the marked tables and databases live in the history's database, introduced by `20261108000000_favourites.sql`, with positions initialized by `20261109000000_favourites_order.sql`, and reached through `QueryHistory::saved_queries`, `saved_query_folders` and `favourites`. ## Rationale - **The same database.** Saved queries already live there, so a folder or a keyword is a column or a table beside them, in one transaction and one migration chain, and `delete_for_connection` removes all of a connection's favourites in one call. - **Integer ids, not UUIDs.** A folder is a row of `saved_query_folders` with an `INTEGER` key, as a saved query has. macOS's UUID ids are not kept; a later importer maps them by name and place, as [0006](0006-connection-library.md) does for groups. -- **A folder is per connection**, with a parent id. Siblings never share a name in any case. Deleting a folder deletes the folders in it and leaves their queries at the top, as deleting a group does ([0006](0006-connection-library.md)). A folder never moves inside itself. -- **A keyword is one word**, at most 64 characters with no whitespace, unique among a connection's queries in any case, as macOS's unique index on keyword and connection. Folders nest without a depth limit, as on macOS. -- **Order is a number per place**, numbered from 0 again on each move, so a place always holds each position once. +- **A folder is per connection**, with a parent id. New or renamed siblings cannot share a name after NFC normalization and Unicode lowercasing. Validation runs under the SQLite write lock, including across separately opened handles. Deleting a folder deletes the folders in it and leaves their queries at the top, as deleting a group does ([0006](0006-connection-library.md)). A folder never moves inside itself. +- **A keyword is one word**, at most 64 characters with no whitespace, unique among a connection's queries after NFC normalization and Unicode lowercasing, as macOS's unique index on keyword and connection. Folders nest without a depth limit, as on macOS. +- **Order is a number per place**, dense from 0 within each connection and parent. Inserts append, moves compact both places, and deletion compacts the old place. Replacing a saved query preserves its identity and metadata. - **A favourite table is keyed by connection, database, schema and name**, the empty string standing for none so the key is never `NULL`. A favourite database carries one of four environments, the four macOS buckets, in a column with a check. -- **Errors are `StorageError` variants with stable codes**: `storage.keyword_taken`, `keyword_invalid`, `folder_name_taken` and `folder_cycle`, with `not_found` and `empty_name` as before. +- **Errors are `StorageError` variants with stable codes**: `storage.keyword_taken`, `keyword_invalid`, `folder_name_taken`, `folder_name_invalid` and `folder_cycle`, with `not_found` and `empty_name` as before. ## Consequences - A database an earlier build wrote is copied beside itself before the migration ([0012](0012-copies-before-a-format-upgrade.md)); a build before this one refuses it, as it refuses any newer one. A copy made from the older format holds none of the new tables, but one a later migration makes holds them, so deleting a folder, a favourite or a connection's data trims the copies as a saved query's delete does, and the copies' sweep covers folders by id. +- Writes acquire `BEGIN IMMEDIATE` before reading or validating. Queries, folders and catalog favorites share one revision feed from `QueryHistory`; only committed changes publish a revision. `SavedQueries::snapshot` reads queries and folders in one transaction. A connection purge commits all four tables together. +- Folder deletion removes the live subtree leaf first, without a nesting limit, and appends its queries after existing root queries. Upgrade copies remove those same folder IDs. Before trimming, a copy refreshes surviving folder names and placement from the live database, adding any missing ancestors. Query IDs and SQL remain unchanged. The dedicated copy connection disables foreign keys while replacing its folder graph, repairs query references, and validates them before committing. Every trim holds the live write lock so concurrent trims cannot restore a pending deletion. - `SavedQuery` gains `keyword`, `folder_id` and `order`. `NewSavedQuery` is unchanged: a save keeps the keyword and the place of the query it replaces. - Not here: the macOS team library, linked folders and per-file favourites, which stay outside the core, and the FFI surface, which a later change adds when Windows or macOS shows favourites. - The Linux sidebar shows the folders, the keyword expansion and the marked tables and databases in later changes, each its own pull request. diff --git a/linux/changelog.d/4116.changed.md b/linux/changelog.d/4116.changed.md new file mode 100644 index 0000000000..8aa273b74a --- /dev/null +++ b/linux/changelog.d/4116.changed.md @@ -0,0 +1 @@ +Saved queries keep their folder, keyword, and order when replaced. diff --git a/linux/docs/storage.md b/linux/docs/storage.md index 3c36a0dea6..69fe1422ae 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -192,7 +192,8 @@ at compile time with `sqlx::migrate!` and run by `QueryHistory::open`. `20260914000000_create_history.sql` creates the `history` table with `query_folded`, the trigram index `history_search` over it, `history_page_idx` on `(pinned DESC, executed_at DESC, id DESC)` for -paging, and the `saved_queries` table. +paging, and the `saved_queries` table. Favorites metadata, ordering, coherent reads +and mutation notifications follow [core ADR 0017](../../core/docs/decisions/0017-favourites.md). **An applied migration is never edited.** Each change is a new timestamped file with its own fixture test. Editing one in place changes its checksum, From 0faaafe6e60e5a88de8ebd569b95084e48d8cd19 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 02:30:12 +0700 Subject: [PATCH 19/23] test(core-storage): separate the favorites migration fixture --- .../favourites_migration_tests.rs | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/core/crates/storage/src/query_history/favourites_migration_tests.rs b/core/crates/storage/src/query_history/favourites_migration_tests.rs index 5f381e8fa4..84d62ffd09 100644 --- a/core/crates/storage/src/query_history/favourites_migration_tests.rs +++ b/core/crates/storage/src/query_history/favourites_migration_tests.rs @@ -90,13 +90,7 @@ async fn original_schema_upgrade_preserves_queries_and_assigns_connection_scoped assert_copy_kept(&paths, 1).await.close().await.expect("close copy"); } -#[tokio::test] -async fn favorites_schema_upgrade_preserves_filing_and_metadata_and_normalizes_positions() { - let root = tempfile::tempdir().expect("tempdir"); - let (paths, pool) = old_database(&root, 2).await; - let connection = Uuid::new_v4(); - let other = Uuid::new_v4(); - insert_queries(&pool, connection, other).await; +async fn insert_favorites(pool: &SqlitePool, connection: Uuid, other: Uuid) { for (id, owner, name, parent, order) in [ (1, connection, "Reports", None, 8), (2, connection, "Archive", None, 2), @@ -112,22 +106,32 @@ async fn favorites_schema_upgrade_preserves_filing_and_metadata_and_normalizes_p .bind(name) .bind(parent) .bind(order) - .execute(&pool) + .execute(pool) .await .expect("folder fixture"); } sqlx::query("UPDATE saved_queries SET folder_id = 3, keyword = 'daily', sort_order = 9 WHERE id = 42") - .execute(&pool) + .execute(pool) .await .expect("file query"); sqlx::query("UPDATE saved_queries SET sort_order = 4 WHERE id <> 42") - .execute(&pool) + .execute(pool) .await .expect("root query orders"); sqlx::query("INSERT INTO favourite_tables (connection_id, database, schema, name, created_at) VALUES (?, 'shop', 'public', 'orders', 31)") - .bind(connection.to_string()).execute(&pool).await.expect("table fixture"); + .bind(connection.to_string()).execute(pool).await.expect("table fixture"); sqlx::query("INSERT INTO favourite_databases (connection_id, database, environment, created_at) VALUES (?, 'shop', 'production', 32)") - .bind(connection.to_string()).execute(&pool).await.expect("database fixture"); + .bind(connection.to_string()).execute(pool).await.expect("database fixture"); +} + +#[tokio::test] +async fn favorites_schema_upgrade_preserves_filing_and_metadata_and_normalizes_positions() { + let root = tempfile::tempdir().expect("tempdir"); + let (paths, pool) = old_database(&root, 2).await; + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + insert_queries(&pool, connection, other).await; + insert_favorites(&pool, connection, other).await; pool.close().await; let history = QueryHistory::open(&paths).await.expect("upgrade"); From 5260c4a65e60ce67b31e7e58a9813480af505d1b Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 02:40:01 +0700 Subject: [PATCH 20/23] fix(core-storage): assign query folders without changing their order --- core/crates/storage/src/saved_queries/mod.rs | 18 +++++++++++++ .../src/saved_queries/ordering_tests.rs | 25 +++++++++++++++++++ core/docs/decisions/0017-favourites.md | 2 +- 3 files changed, 44 insertions(+), 1 deletion(-) diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index 2267928308..474e3d5690 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -254,7 +254,21 @@ impl SavedQueries { Ok(()) } + pub async fn set_folder(&self, id: i64, folder: Option) -> Result<(), StorageError> { + self.move_query(id, folder, None, true).await + } + pub async fn move_to_folder(&self, id: i64, folder: Option, before: Option) -> Result<(), StorageError> { + self.move_query(id, folder, before, false).await + } + + async fn move_query( + &self, + id: i64, + folder: Option, + before: Option, + keep_position: bool, + ) -> Result<(), StorageError> { let mut connection = self.pool.acquire().await?; let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; let row = sqlx::query("SELECT connection_id, folder_id FROM saved_queries WHERE id = ?") @@ -274,6 +288,10 @@ impl SavedQueries { return Err(StorageError::NotFound); } } + if keep_position && old_folder == folder { + transaction.commit().await?; + return Ok(()); + } if before == Some(id) { return if old_folder == folder { Ok(()) diff --git a/core/crates/storage/src/saved_queries/ordering_tests.rs b/core/crates/storage/src/saved_queries/ordering_tests.rs index a23d3f811e..460a733c5e 100644 --- a/core/crates/storage/src/saved_queries/ordering_tests.rs +++ b/core/crates/storage/src/saved_queries/ordering_tests.rs @@ -294,3 +294,28 @@ async fn a_failed_connection_purge_preserves_every_kind_of_favorite_and_its_revi assert!(favourites.tables(connection).await.expect("tables").is_empty()); assert!(favourites.databases(connection).await.expect("databases").is_empty()); } + +#[tokio::test] +async fn assigning_the_same_folder_preserves_position_and_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let a = save(&store, connection, "a").await; + let b = save(&store, connection, "b").await; + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + store.set_folder(a, Some(folder)).await.expect("file a"); + store.set_folder(b, Some(folder)).await.expect("file b"); + let changes = store.changes(); + store.set_folder(a, Some(folder)).await.expect("same folder"); + assert_eq!(order(&store, connection, Some(folder)).await, [a, b]); + assert!(!changes.has_changed().expect("no revision")); + store.set_folder(a, None).await.expect("move to root"); + assert_eq!(order(&store, connection, None).await, [a]); + assert_eq!(order(&store, connection, Some(folder)).await, [b]); + assert!(changes.has_changed().expect("revision")); +} diff --git a/core/docs/decisions/0017-favourites.md b/core/docs/decisions/0017-favourites.md index fc18d95755..b771612102 100644 --- a/core/docs/decisions/0017-favourites.md +++ b/core/docs/decisions/0017-favourites.md @@ -17,7 +17,7 @@ The folders, the keywords, the order and the marked tables and databases live in - **Integer ids, not UUIDs.** A folder is a row of `saved_query_folders` with an `INTEGER` key, as a saved query has. macOS's UUID ids are not kept; a later importer maps them by name and place, as [0006](0006-connection-library.md) does for groups. - **A folder is per connection**, with a parent id. New or renamed siblings cannot share a name after NFC normalization and Unicode lowercasing. Validation runs under the SQLite write lock, including across separately opened handles. Deleting a folder deletes the folders in it and leaves their queries at the top, as deleting a group does ([0006](0006-connection-library.md)). A folder never moves inside itself. - **A keyword is one word**, at most 64 characters with no whitespace, unique among a connection's queries after NFC normalization and Unicode lowercasing, as macOS's unique index on keyword and connection. Folders nest without a depth limit, as on macOS. -- **Order is a number per place**, dense from 0 within each connection and parent. Inserts append, moves compact both places, and deletion compacts the old place. Replacing a saved query preserves its identity and metadata. +- **Order is a number per place**, dense from 0 within each connection and parent. Inserts append, moves compact both places, and deletion compacts the old place. Replacing a saved query preserves its identity and metadata. `set_folder` preserves the position when the destination is unchanged; `move_to_folder` also permits an explicit reorder. Both decide under the write lock. - **A favourite table is keyed by connection, database, schema and name**, the empty string standing for none so the key is never `NULL`. A favourite database carries one of four environments, the four macOS buckets, in a column with a check. - **Errors are `StorageError` variants with stable codes**: `storage.keyword_taken`, `keyword_invalid`, `folder_name_taken`, `folder_name_invalid` and `folder_cycle`, with `not_found` and `empty_name` as before. From 7883c54bdd4ee5d67e1889edb81f744882b60929 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 02:41:02 +0700 Subject: [PATCH 21/23] test(linux-sidebar): retain saved query concurrency coverage in the stack --- core/crates/storage/src/saved_queries/mod.rs | 93 ++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index 2267928308..a746037d1a 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -857,4 +857,97 @@ mod tests { "renamed" ); } + #[tokio::test] + async fn concurrent_new_saves_never_overwrite_the_winner() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + let (first, second) = tokio::join!( + store.save_if_new(new_query("daily", "SELECT 1", connection)), + store.save_if_new(new_query("daily", "SELECT 2", connection)), + ); + let first = first.expect("first save"); + let second = second.expect("second save"); + assert_ne!(first.is_some(), second.is_some()); + let saved = store.list(Some(connection)).await.expect("list"); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].query, if first.is_some() { "SELECT 1" } else { "SELECT 2" }); + } + + #[tokio::test] + async fn concurrent_saves_report_exactly_one_replacement_and_keep_the_id() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + let (first, second) = tokio::join!( + store.save(new_query("daily", "SELECT 1", connection)), + store.save(new_query("daily", "SELECT 2", connection)), + ); + let first = first.expect("first save"); + let second = second.expect("second save"); + assert_ne!(first.replaced, second.replaced); + assert_eq!(first.id, second.id); + assert_eq!(store.list(Some(connection)).await.expect("list").len(), 1); + } + + #[tokio::test] + async fn every_write_moves_the_revision_every_handle_follows() { + let root = tempfile::tempdir().expect("tempdir"); + let paths = StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro"); + let history = QueryHistory::open(&paths).await.expect("open"); + let (writer, follower) = (history.saved_queries(), history.saved_queries()); + let mut changes = follower.changes(); + let connection = Uuid::new_v4(); + let mut moved = || { + let moved = changes.has_changed().expect("the sender lives"); + changes.mark_unchanged(); + moved + }; + + let saved = writer + .save(new_query("daily", "SELECT 1", connection)) + .await + .expect("save"); + assert!(moved(), "a save"); + writer + .save_if_new(new_query("weekly", "SELECT 2", connection)) + .await + .expect("save if new"); + assert!(moved(), "a save of a new name"); + writer.rename(saved.id, "nightly").await.expect("rename"); + assert!(moved(), "a rename"); + writer.delete(saved.id).await.expect("delete"); + assert!(moved(), "a delete"); + writer + .delete_for_connection(connection) + .await + .expect("delete for connection"); + assert!(moved(), "a connection's queries removed"); + } + + #[tokio::test] + async fn a_read_or_a_write_that_changed_nothing_leaves_the_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + store + .save(new_query("daily", "SELECT 1", connection)) + .await + .expect("save"); + let changes = store.changes(); + + store.list(Some(connection)).await.expect("list"); + store + .save_if_new(new_query("daily", "SELECT 2", connection)) + .await + .expect("save if new"); + store.rename(404, "gone").await.expect_err("no such query"); + store.delete(404).await.expect_err("no such query"); + store + .delete_for_connection(Uuid::new_v4()) + .await + .expect("delete for a connection with none"); + + assert!(!changes.has_changed().expect("the sender lives")); + } } From e7e71d60e26fdcc2f7b19b7b41dcdee01c964261 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 02:43:55 +0700 Subject: [PATCH 22/23] fix(linux-sidebar): keep favorite folders coherent and accessible --- linux/changelog.d/4130.added.md | 2 +- .../app/src/ui/workspace/favorite_folders.rs | 438 ++++++++++ linux/crates/app/src/ui/workspace/mod.rs | 1 + .../ui/workspace/sidebar/favorites_index.rs | 229 ++++++ .../ui/workspace/sidebar/favorites_pane.rs | 769 ++++++------------ .../workspace/sidebar/favorites_pane_tests.rs | 382 +++++++++ .../ui/workspace/sidebar/favorites_rows.rs | 340 ++++++++ .../app/src/ui/workspace/status_pages.rs | 28 +- .../app/src/ui/workspace/workspace_shell.rs | 72 +- linux/docs/storage.md | 15 +- linux/po/POTFILES.in | 4 + 11 files changed, 1722 insertions(+), 558 deletions(-) create mode 100644 linux/crates/app/src/ui/workspace/favorite_folders.rs create mode 100644 linux/crates/app/src/ui/workspace/sidebar/favorites_index.rs create mode 100644 linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs create mode 100644 linux/crates/app/src/ui/workspace/sidebar/favorites_rows.rs diff --git a/linux/changelog.d/4130.added.md b/linux/changelog.d/4130.added.md index c976171068..6f75e6aca4 100644 --- a/linux/changelog.d/4130.added.md +++ b/linux/changelog.d/4130.added.md @@ -1 +1 @@ -Favorites are filed in folders that nest, made, renamed and deleted from the list. +Organize saved queries in folders in the Favorites sidebar. diff --git a/linux/crates/app/src/ui/workspace/favorite_folders.rs b/linux/crates/app/src/ui/workspace/favorite_folders.rs new file mode 100644 index 0000000000..b871b144de --- /dev/null +++ b/linux/crates/app/src/ui/workspace/favorite_folders.rs @@ -0,0 +1,438 @@ +use gtk4 as gtk; +use gtk4::prelude::*; +use gtk4::subclass::prelude::*; +use libadwaita as adw; +use libadwaita::prelude::{AdwDialogExt, AlertDialogExt, PreferencesGroupExt}; +use tablepro_storage::StorageError; +use tablepro_storage::saved_queries::{SavedQuery, SavedQueryFolder}; +use uuid::Uuid; + +use super::WorkspaceShell; +use crate::i18n::{gettext, gettext_f}; + +impl WorkspaceShell { + pub(crate) fn move_favorite(&self, id: i64, folder: Option) { + self.change_favorites_with( + async move |history| history.saved_queries().set_folder(id, folder).await, + gettext("Could not move that saved query."), + move_failure_text, + ); + } + + #[cfg(test)] + pub(crate) fn create_folder(&self, name: String, parent: Option) { + if let Some(connection) = self.front().and_then(|front| front.connection_id()) { + self.create_folder_for(connection, name, parent); + } + } + + fn create_folder_for(&self, connection: Uuid, name: String, parent: Option) { + self.change_favorites_with( + async move |history| { + history + .saved_query_folders() + .create(connection, &name, parent) + .await + .map(drop) + }, + gettext("Could not create that folder."), + folder_failure_text, + ); + } + + fn rename_folder(&self, id: i64, name: String) { + self.change_favorites_with( + async move |history| history.saved_query_folders().rename(id, &name).await, + gettext("Could not rename that folder."), + folder_failure_text, + ); + } + + pub(crate) fn delete_folder(&self, id: i64) { + self.change_favorites_with( + async move |history| history.saved_query_folders().delete(id).await, + gettext("Could not delete that folder."), + folder_failure_text, + ); + } + + pub(super) fn ask_folder_name(&self, parent: Option, rename: Option) { + let Some(connection) = rename + .as_ref() + .or(parent.as_ref()) + .map(|folder| folder.connection_id) + .or_else(|| self.front().and_then(|front| front.connection_id())) + else { + return; + }; + let title = match (&rename, &parent) { + (Some(_), _) => gettext("Rename Folder"), + (None, Some(_)) => gettext("New Subfolder"), + (None, None) => gettext("New Folder"), + }; + let verb = if rename.is_some() { + gettext("Rename") + } else { + gettext("Create") + }; + let dialog = adw::AlertDialog::new(Some(&title), None); + let entry = adw::EntryRow::builder() + .title(gettext("Name")) + .activates_default(true) + .build(); + if let Some(folder) = &rename { + entry.set_text(&folder.name); + } + let group = adw::PreferencesGroup::new(); + group.add(&entry); + dialog.set_extra_child(Some(&group)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("ok", &verb); + dialog.set_response_appearance("ok", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("ok")); + dialog.set_close_response("cancel"); + crate::ui::name_entry::require_name(&dialog, "ok", &entry); + dialog.set_focus(Some(&entry)); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let name = entry.text().trim().to_owned(); + let Some(shell) = shell.upgrade().filter(|_| response == "ok" && !name.is_empty()) else { + return; + }; + match &rename { + Some(folder) if name != folder.name => shell.rename_folder(folder.id, name), + Some(_) => {} + None => shell.create_folder_for(connection, name, parent.as_ref().map(|folder| folder.id)), + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + pub(super) fn ask_folder_deletion(&self, folder: SavedQueryFolder) { + let dialog = adw::AlertDialog::new( + Some(&gettext_f("Delete “{name}”?", &[("name", &folder.name)])), + Some(&gettext( + "This folder and its subfolders will be deleted. Their saved queries will move to the top level.", + )), + ); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("delete", &gettext("Delete")); + dialog.set_response_appearance("delete", adw::ResponseAppearance::Destructive); + dialog.set_default_response(Some("cancel")); + dialog.set_close_response("cancel"); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + if let (true, Some(shell)) = (response == "delete", shell.upgrade()) { + shell.delete_folder(folder.id); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + pub(super) fn ask_folder_for(&self, favorite: SavedQuery) { + let Some(pane) = self.imp().favorites.get() else { + return; + }; + let folders = pane.folder_destinations(); + let top = gettext("No Folder"); + let names: Vec<&str> = std::iter::once(top.as_str()) + .chain(folders.iter().map(|(_, path)| path.as_str())) + .collect(); + let choice = gtk::DropDown::from_strings(&names); + choice.set_enable_search(true); + choice.update_property(&[gtk::accessible::Property::Label(&gettext("Folder"))]); + let at = match favorite.folder_id { + None => 0, + Some(id) => folders + .iter() + .position(|(held, _)| *held == id) + .and_then(|position| u32::try_from(position + 1).ok()) + .unwrap_or(gtk::INVALID_LIST_POSITION), + }; + choice.set_selected(at); + choice.set_tooltip_text(names.get(at as usize).copied()); + let dialog = adw::AlertDialog::new(Some(&gettext_f("Move “{name}”", &[("name", &favorite.name)])), None); + dialog.set_extra_child(Some(&choice)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("move", &gettext("Move")); + dialog.set_response_appearance("move", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("move")); + dialog.set_close_response("cancel"); + dialog.set_response_enabled("move", false); + choice.connect_selected_notify(gtk::glib::clone!( + #[weak] + dialog, + move |choice| { + dialog.set_response_enabled( + "move", + choice.selected() != gtk::INVALID_LIST_POSITION && choice.selected() != at, + ); + let label = choice + .selected_item() + .and_downcast::() + .map(|item| item.string()); + choice.set_tooltip_text(label.as_deref()); + } + )); + dialog.set_focus(Some(&choice)); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let Some(shell) = shell.upgrade().filter(|_| response == "move") else { + return; + }; + let Some(folder) = destination(&folders, choice.selected()) else { + return; + }; + if folder != favorite.folder_id { + shell.move_favorite(favorite.id, folder); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } +} + +fn destination(folders: &[(i64, String)], selected: u32) -> Option> { + if selected == 0 { + Some(None) + } else { + folders.get(selected as usize - 1).map(|(id, _)| Some(*id)) + } +} + +fn folder_failure_text(error: &StorageError, fallback: &str) -> String { + match error { + StorageError::FolderNameTaken => gettext("That name is already used by another folder in the same place."), + StorageError::FolderNameInvalid => gettext("Folder names cannot contain control characters."), + StorageError::TooLarge { .. } => gettext("That folder name is too long."), + StorageError::EmptyName => gettext("Enter a name for the folder."), + StorageError::FolderCycle { .. } => gettext("A folder cannot be moved inside itself or one of its subfolders."), + StorageError::NotFound => gettext("That folder was deleted elsewhere."), + StorageError::NotInitialised => gettext("Favorites are unavailable. Restart TablePro to try again."), + _ => fallback.to_owned(), + } +} + +fn move_failure_text(error: &StorageError, fallback: &str) -> String { + match error { + StorageError::NotFound => gettext("The saved query or destination folder was deleted elsewhere."), + StorageError::NotInitialised => gettext("Favorites are unavailable. Restart TablePro to try again."), + _ => fallback.to_owned(), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::test_support::{descendants, finish_on_main, wait_until}; + use crate::ui::session_window::tests::{TestWindow, WAIT}; + use crate::workspace::{answer, visible_alert}; + + fn ready(test: &TestWindow) -> tablepro_storage::QueryHistory { + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("history ready"); + wait_until(WAIT, || test.hold.live() == 0).expect("initial work finished"); + test.services.history().store().expect("history") + } + + fn folders(test: &TestWindow, owner: Uuid) -> Vec { + let history = test.services.history().store().expect("history"); + let task = test + .services + .tasks + .spawn_task(async move { history.saved_query_folders().list(owner).await }); + finish_on_main(WAIT, task) + .expect("read finished") + .expect("task") + .expect("folders") + } + + #[gtk4::test] + fn a_folder_write_keeps_its_hold_after_the_window_closes() { + let test = TestWindow::connected("FolderWriteClosed"); + ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let shell = test.window.shell().expect("shell"); + let (release, released) = tokio::sync::oneshot::channel(); + shell.change_favorites_with( + move |history| async move { + released.await.expect("release write"); + history + .saved_query_folders() + .create(owner, "Reports", None) + .await + .map(drop) + }, + "Create failed".to_owned(), + folder_failure_text, + ); + assert_eq!(test.hold.live(), 1); + let held = test.hold_tokens.borrow().last().expect("folder hold").clone(); + test.window.close(); + wait_until(WAIT, || !test.window.is_visible()).expect("window closed"); + assert!(held.upgrade().is_some()); + release.send(()).expect("write still waiting"); + wait_until(WAIT, || held.upgrade().is_none()).expect("folder write finished"); + assert_eq!(folders(&test, owner)[0].name, "Reports"); + } + + #[gtk4::test] + fn a_new_folder_dialog_keeps_the_connection_it_opened_for() { + let test = TestWindow::connected("FolderCapturedOwner"); + ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let shell = test.window.shell().expect("shell"); + shell.ask_folder_name(None, None); + let dialog = visible_alert(&test.window).expect("new folder prompt"); + let entry = descendants(&dialog) + .into_iter() + .find_map(|widget| widget.downcast::().ok()) + .expect("entry"); + assert!(!dialog.is_response_enabled("ok")); + entry.set_text("Reports"); + assert!(dialog.is_response_enabled("ok")); + shell.imp().front.replace(None); + shell.reload_favorites(); + answer(&test.window, "ok"); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || test.hold.live() == 0).expect("create finished"); + let saved = folders(&test, owner); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].name, "Reports"); + assert_eq!(saved[0].connection_id, owner); + } + + #[gtk4::test] + fn choosing_the_current_destination_does_not_reorder_the_query() { + let test = TestWindow::connected("FolderMoveUnchanged"); + let history = ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let task = test.services.tasks.spawn_task(async move { + let store = history.saved_queries(); + for name in ["First", "Second"] { + store + .save(tablepro_storage::saved_queries::NewSavedQuery { + name: name.to_owned(), + query: "SELECT 1".to_owned(), + connection_id: owner, + connection_name: "local".to_owned(), + }) + .await + .expect("save"); + } + store.snapshot(owner).await.expect("snapshot") + }); + let before = finish_on_main(WAIT, task).expect("read finished").expect("task"); + let favorite = before.queries[0].clone(); + let shell = test.window.shell().expect("shell"); + shell.imp().favorites.get().expect("pane").show(before.clone()); + let history = test.services.history().store().expect("history"); + let changes = history.saved_queries().changes(); + shell.ask_folder_for(favorite.clone()); + let dialog = visible_alert(&test.window).expect("move prompt"); + assert!(!dialog.is_response_enabled("move")); + answer(&test.window, "move"); + assert_eq!(test.hold.live(), 0); + assert!(!changes.has_changed().expect("no change")); + shell.move_favorite(favorite.id, None); + wait_until(WAIT, || test.hold.live() == 0).expect("no-op finished"); + let task = test + .services + .tasks + .spawn_task(async move { history.saved_queries().snapshot(owner).await }); + let after = finish_on_main(WAIT, task) + .expect("read finished") + .expect("task") + .expect("snapshot"); + assert_eq!(after, before); + assert!(!changes.has_changed().expect("no revision")); + } + + #[gtk4::test] + fn folder_deletion_requires_confirmation_and_preserves_queries() { + let test = TestWindow::connected("FolderDeleteConfirmed"); + let history = ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let task = test.services.tasks.spawn_task(async move { + let folders = history.saved_query_folders(); + let parent = folders.create(owner, "Reports", None).await.expect("parent"); + let child = folders.create(owner, "Monthly", Some(parent)).await.expect("child"); + let saved = history + .saved_queries() + .save(tablepro_storage::saved_queries::NewSavedQuery { + name: "Report".to_owned(), + query: "SELECT 1".to_owned(), + connection_id: owner, + connection_name: "local".to_owned(), + }) + .await + .expect("save"); + history + .saved_queries() + .move_to_folder(saved.id, Some(child), None) + .await + .expect("file"); + folders + .list(owner) + .await + .expect("folders") + .into_iter() + .find(|folder| folder.id == parent) + .expect("parent") + }); + let parent = finish_on_main(WAIT, task).expect("read finished").expect("task"); + let shell = test.window.shell().expect("shell"); + shell.ask_folder_deletion(parent.clone()); + let dialog = visible_alert(&test.window).expect("delete prompt"); + assert_eq!(dialog.default_response().as_deref(), Some("cancel")); + assert_eq!( + dialog.response_appearance("delete"), + adw::ResponseAppearance::Destructive + ); + answer(&test.window, "cancel"); + wait_until(WAIT, || visible_alert(&test.window).is_none()).expect("cancelled"); + assert_eq!(folders(&test, owner).len(), 2); + shell.ask_folder_deletion(parent); + answer(&test.window, "delete"); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || test.hold.live() == 0).expect("deleted"); + assert!(folders(&test, owner).is_empty()); + let history = test.services.history().store().expect("history"); + let task = test + .services + .tasks + .spawn_task(async move { history.saved_queries().list(Some(owner)).await }); + let saved = finish_on_main(WAIT, task) + .expect("read finished") + .expect("task") + .expect("queries"); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].query, "SELECT 1"); + assert_eq!(saved[0].folder_id, None); + } + + #[test] + fn a_destination_never_converts_an_invalid_selection_into_the_root() { + let choices = vec![(42, "/No Folder".to_owned()), (7, "/Reports/Monthly".to_owned())]; + assert_eq!(destination(&choices, 0), Some(None)); + assert_eq!(destination(&choices, 1), Some(Some(42))); + assert_eq!(destination(&choices, 2), Some(Some(7))); + assert_eq!(destination(&choices, 3), None); + assert_eq!(destination(&choices, gtk::INVALID_LIST_POSITION), None); + } + + #[test] + fn folder_and_move_failures_name_the_missing_record() { + assert_eq!( + folder_failure_text(&StorageError::NotFound, "fallback"), + "That folder was deleted elsewhere." + ); + assert_eq!( + move_failure_text(&StorageError::NotFound, "fallback"), + "The saved query or destination folder was deleted elsewhere." + ); + assert_eq!( + folder_failure_text(&StorageError::FolderNameTaken, "fallback"), + "That name is already used by another folder in the same place." + ); + } +} diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index ca710b78be..7f9ce9f95f 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -13,6 +13,7 @@ mod database_transfer; mod definitions; mod diagram; mod editor_label; +mod favorite_folders; mod finished_work; mod health_banner; mod imp; diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_index.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_index.rs new file mode 100644 index 0000000000..741cee5351 --- /dev/null +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_index.rs @@ -0,0 +1,229 @@ +use std::collections::{HashMap, HashSet}; + +use tablepro_storage::saved_queries::{SavedQueriesSnapshot, SavedQuery, SavedQueryFolder}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub(super) enum Key { + Folder(i64), + Query(i64), +} + +impl Key { + pub(super) fn target(self) -> String { + match self { + Self::Folder(id) => format!("f{id}"), + Self::Query(id) => format!("q{id}"), + } + } + + pub(super) fn parse(target: &str) -> Option { + let (kind, id) = target.split_at_checked(1)?; + let id = id.parse().ok()?; + match kind { + "f" => Some(Self::Folder(id)), + "q" => Some(Self::Query(id)), + _ => None, + } + } +} + +#[derive(Debug, Clone)] +pub(super) enum Node { + Folder(SavedQueryFolder), + Query(SavedQuery), +} + +impl Node { + pub(super) fn key(&self) -> Key { + match self { + Self::Folder(folder) => Key::Folder(folder.id), + Self::Query(query) => Key::Query(query.id), + } + } + + pub(super) fn name(&self) -> &str { + match self { + Self::Folder(folder) => &folder.name, + Self::Query(query) => &query.name, + } + } + + pub(super) fn parent(&self) -> Option { + match self { + Self::Folder(folder) => folder.parent_id, + Self::Query(query) => query.folder_id, + } + } + + fn order(&self) -> (u8, i64, String, i64) { + match self { + Self::Folder(folder) => (0, folder.order, folder.name.to_lowercase(), folder.id), + Self::Query(query) => (1, query.order, query.name.to_lowercase(), query.id), + } + } +} + +#[derive(Default)] +pub(super) struct Index { + pub(super) nodes: HashMap, + children: HashMap, Vec>, + paths: HashMap, +} + +impl Index { + pub(super) fn new(snapshot: SavedQueriesSnapshot) -> Option { + let mut index = Self::default(); + let mut owners = HashSet::new(); + for node in snapshot + .folders + .into_iter() + .map(Node::Folder) + .chain(snapshot.queries.into_iter().map(Node::Query)) + { + owners.insert(match &node { + Node::Folder(folder) => folder.connection_id, + Node::Query(query) => query.connection_id, + }); + index.children.entry(node.parent()).or_default().push(node.key()); + if index.nodes.insert(node.key(), node).is_some() { + return None; + } + } + if owners.len() > 1 { + return None; + } + for keys in index.children.values_mut() { + keys.sort_by_cached_key(|key| index.nodes[key].order()); + } + let mut pending = vec![(None, String::new())]; + let mut visited = HashSet::new(); + while let Some((parent, path)) = pending.pop() { + for key in index.children.get(&parent).into_iter().flatten() { + if !visited.insert(*key) { + return None; + } + if let Key::Folder(id) = key { + let name = index.nodes[key].name().replace('\\', "\\\\").replace('/', "\\/"); + let path = format!("{path}/{name}"); + index.paths.insert(*id, path.clone()); + pending.push((Some(*id), path)); + } + } + } + (visited.len() == index.nodes.len()).then_some(index) + } + + pub(super) fn children(&self, parent: Option) -> &[Key] { + self.children.get(&parent).map_or(&[], Vec::as_slice) + } + + pub(super) fn path(&self, id: i64) -> Option<&str> { + self.paths.get(&id).map(String::as_str) + } + + pub(super) fn destinations(&self) -> Vec<(i64, String)> { + let mut folders: Vec<_> = self.paths.iter().map(|(id, path)| (*id, path.clone())).collect(); + folders.sort_by_cached_key(|(id, path)| (path.to_lowercase(), path.clone(), *id)); + folders + } + + #[cfg(test)] + pub(super) fn queries(&self) -> Vec { + let mut queries: Vec<_> = self + .nodes + .values() + .filter_map(|node| match node { + Node::Query(query) => Some(query.clone()), + Node::Folder(_) => None, + }) + .collect(); + queries.sort_by_key(|query| (query.folder_id, query.order, query.name.to_lowercase(), query.id)); + queries + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::time::SystemTime; + use uuid::Uuid; + + fn folder(id: i64, name: &str, parent_id: Option) -> SavedQueryFolder { + SavedQueryFolder { + id, + name: name.to_owned(), + parent_id, + connection_id: Uuid::nil(), + order: 0, + created_at: SystemTime::UNIX_EPOCH, + updated_at: SystemTime::UNIX_EPOCH, + } + } + + #[test] + fn folder_destinations_distinguish_ancestry_separators_and_the_root_label() { + let index = Index::new(SavedQueriesSnapshot { + queries: vec![], + folders: vec![ + folder(1, "Reports", None), + folder(2, "Monthly", Some(1)), + folder(3, "Archive", None), + folder(4, "Monthly", Some(3)), + folder(5, "Reports/Monthly", None), + folder(6, "No Folder", None), + folder(7, "a\\/b", None), + ], + }) + .expect("valid hierarchy"); + assert_eq!( + index.destinations(), + vec![ + (7, "/a\\\\\\/b".to_owned()), + (3, "/Archive".to_owned()), + (4, "/Archive/Monthly".to_owned()), + (6, "/No Folder".to_owned()), + (1, "/Reports".to_owned()), + (2, "/Reports/Monthly".to_owned()), + (5, "/Reports\\/Monthly".to_owned()), + ] + ); + } + + #[test] + fn malformed_hierarchies_are_refused_instead_of_hiding_queries_or_recursing() { + for folders in [ + vec![folder(1, "Orphan", Some(99))], + vec![folder(1, "Cycle", Some(2)), folder(2, "Cycle", Some(1))], + vec![folder(1, "Duplicate", None), folder(1, "Duplicate", None)], + ] { + assert!( + Index::new(SavedQueriesSnapshot { + queries: vec![], + folders + }) + .is_none() + ); + } + } + + #[test] + fn typed_keys_and_sibling_order_are_stable() { + let mut first = folder(8, "Z", None); + first.order = 0; + let mut second = folder(3, "A", None); + second.order = 1; + let index = Index::new(SavedQueriesSnapshot { + queries: vec![], + folders: vec![second, first], + }) + .expect("index"); + assert_eq!(index.children(None), [Key::Folder(8), Key::Folder(3)]); + assert_ne!(Key::Folder(3), Key::Query(3)); + for key in [Key::Folder(3), Key::Query(3)] { + assert_eq!(Key::parse(&key.target()), Some(key)); + } + for text in ["", "😀", "qabc", "x3"] { + assert_eq!(Key::parse(text), None); + } + } +} diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 504c13c2b8..8b77141998 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -1,131 +1,153 @@ +#[path = "favorites_index.rs"] +mod index; +#[path = "favorites_rows.rs"] +mod rows; +#[cfg(test)] +#[path = "favorites_pane_tests.rs"] +mod tests; + +use std::cell::{Cell, RefCell}; +use std::collections::{HashMap, HashSet}; use std::rc::Rc; use gtk4 as gtk; use gtk4::prelude::*; use gtk4::{gio, glib}; use libadwaita as adw; -use tablepro_storage::saved_queries::SavedQuery; +use tablepro_storage::saved_queries::{SavedQueriesSnapshot, SavedQuery, SavedQueryFolder}; -use crate::i18n::{gettext, gettext_f}; +use crate::i18n::gettext; +use index::{Index, Key, Node}; const LIST: &str = "list"; const EMPTY: &str = "empty"; +const ROW: &str = "favorite-row"; +const KEYS: &str = "favorite-keys"; +const RENAME: &str = "rename"; +const DELETE: &str = "delete"; +const MOVE: &str = "move"; +const NEW_FOLDER: &str = "new-folder"; #[derive(Debug, Clone)] pub(crate) enum FavoriteAction { Open(String), Rename(SavedQuery), Delete(SavedQuery), + MoveTo(SavedQuery), + NewFolder(Option), + RenameFolder(SavedQueryFolder), + DeleteFolder(SavedQueryFolder), } type Asked = Rc; - -const ROW: &str = "favorite-row"; -const RENAME: &str = "rename"; -const DELETE: &str = "delete"; -const KEYS: &str = "favorite-keys"; +type SharedIndex = Rc>>; #[derive(Clone)] pub(crate) struct FavoritesPane { + whole: gtk::Box, stack: gtk::Stack, store: gio::ListStore, + tree: gtk::TreeListModel, + index: SharedIndex, + expansion: Rc, selection: gtk::SingleSelection, menu: gtk::PopoverMenu, error: adw::StatusPage, retry: gtk::Button, stale: adw::Banner, + new_folder: gtk::Button, } impl FavoritesPane { pub(crate) fn new(asked: impl Fn(FavoriteAction) + 'static, retry: impl Fn() + 'static) -> Self { + let asked: Asked = Rc::new(asked); let store = gio::ListStore::new::(); + let index: SharedIndex = Rc::default(); + let tree = gtk::TreeListModel::new(store.clone(), false, false, { + let index = index.clone(); + move |item| match *item.downcast_ref::()?.borrow::() { + Key::Folder(id) => Some(model_of(&index.borrow(), Some(id)).upcast()), + Key::Query(_) => None, + } + }); + let expansion = Rc::new(Expansion::default()); + tree.connect_items_changed({ + let expansion = Rc::downgrade(&expansion); + move |tree, _, _, _| { + if let Some(expansion) = expansion.upgrade() { + expansion.observe(tree); + } + } + }); let selection = gtk::SingleSelection::builder() - .model(&store) + .model(&tree) .autoselect(false) .can_unselect(true) .build(); - let list = gtk::ListView::new(Some(selection.clone()), Some(factory())); + let list = gtk::ListView::new(Some(selection.clone()), Some(rows::factory(index.clone()))); list.add_css_class("navigation-sidebar"); list.set_single_click_activate(true); list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); - let asked: Asked = Rc::new(asked); - let opened = asked.clone(); - let model = store.clone(); - list.connect_activate(move |_, position| { - if let Some(favorite) = favorite_at(&model, position) { - opened(FavoriteAction::Open(favorite.query)); + list.connect_activate({ + let (tree, index, asked) = (tree.clone(), index.clone(), asked.clone()); + move |_, position| { + let Some(row) = tree.row(position) else { + return; + }; + match key_of(&row).and_then(|key| index.borrow().nodes.get(&key).cloned()) { + Some(Node::Query(query)) => asked(FavoriteAction::Open(query.query)), + Some(Node::Folder(_)) => row.set_expanded(!row.is_expanded()), + None => {} + } } }); - let menu = install_menu(&list, &store, &selection, &asked); - let scrolled = gtk::ScrolledWindow::builder() - .hscrollbar_policy(gtk::PolicyType::Never) - .child(&list) - .build(); - let retry = Rc::new(retry); - let retry_button = gtk::Button::with_label(&gettext("Try Again")); - retry_button.set_halign(gtk::Align::Center); - retry_button.connect_clicked({ - let retry = retry.clone(); - move |_| retry() - }); - let error = adw::StatusPage::builder() - .title(gettext("Favorites Unavailable")) - .icon_name("dialog-warning-symbolic") - .child(&retry_button) - .build(); - error.add_css_class("compact"); - let stale = adw::Banner::builder() - .title(gettext("Favorites could not be refreshed.")) - .button_label(gettext("Try Again")) - .build(); - stale.connect_button_clicked(move |_| retry()); - let content = gtk::Box::new(gtk::Orientation::Vertical, 0); - content.append(&stale); - scrolled.set_vexpand(true); - content.append(&scrolled); - let empty = adw::StatusPage::builder() - .title(gettext("No Favorites")) - .icon_name("starred-symbolic") - .description(gettext("Save a query from the SQL editor to find it here.")) - .build(); - empty.add_css_class("compact"); - let stack = gtk::Stack::new(); - stack.add_named(&content, Some(LIST)); - stack.add_named(&error, Some("error")); - let loading = adw::StatusPage::builder() - .title(gettext("Loading Favorites")) - .child(&adw::Spinner::new()) + let menu = rows::install_menu(&list, &tree, &index, &selection, &asked); + let (stack, error, retry, stale) = status_pages(&list, Rc::new(retry)); + let new_folder = gtk::Button::builder() + .icon_name("folder-new-symbolic") + .halign(gtk::Align::Start) + .margin_top(6) + .margin_bottom(6) + .margin_start(6) + .sensitive(false) .build(); - loading.add_css_class("compact"); - stack.add_named(&loading, Some("loading")); - let disconnected = adw::StatusPage::builder() - .title(gettext("No Connection Selected")) - .description(gettext("Open a connection to see its saved queries.")) - .icon_name("starred-symbolic") - .build(); - disconnected.add_css_class("compact"); - stack.add_named(&disconnected, Some("disconnected")); - stack.add_named(&empty, Some(EMPTY)); - stack.set_visible_child_name(EMPTY); + new_folder.add_css_class("flat"); + new_folder.set_tooltip_text(Some(&gettext("New Folder"))); + new_folder.update_property(&[gtk::accessible::Property::Label(&gettext("New Folder"))]); + new_folder.connect_clicked(move |_| asked(FavoriteAction::NewFolder(None))); + let whole = gtk::Box::new(gtk::Orientation::Vertical, 0); + whole.append(&stack); + whole.append(&new_folder); Self { + whole, stack, store, + tree, + index, + expansion, selection, menu, error, - retry: retry_button, + retry, stale, + new_folder, } } pub(crate) fn widget(&self) -> gtk::Widget { - self.stack.clone().upcast() + self.whole.clone().upcast() } pub(crate) fn clear(&self) { self.menu.popdown(); + self.expansion.reset_rows(); + self.expansion.expanded.borrow_mut().clear(); + self.index.replace(Rc::default()); self.store.remove_all(); + self.expansion.updating.set(false); + self.selection.set_selected(gtk::INVALID_LIST_POSITION); self.stale.set_revealed(false); + self.new_folder.set_sensitive(false); } pub(crate) fn no_connection(&self) { @@ -134,6 +156,7 @@ impl FavoritesPane { } pub(crate) fn loading(&self) { + self.new_folder.set_sensitive(false); self.stale.set_revealed(false); if self.store.n_items() == 0 { self.stack.set_visible_child_name("loading"); @@ -150,6 +173,7 @@ impl FavoritesPane { } pub(crate) fn failed(&self) { + self.new_folder.set_sensitive(false); if self.store.n_items() > 0 { self.stale.set_revealed(true); return; @@ -160,505 +184,192 @@ impl FavoritesPane { self.stack.set_visible_child_name("error"); } - pub(crate) fn show(&self, favorites: Vec) { + pub(crate) fn show(&self, snapshot: SavedQueriesSnapshot) { + let Some(index) = Index::new(snapshot) else { + tracing::warn!("invalid saved query folder hierarchy"); + self.failed(); + return; + }; self.menu.popdown(); - let selected = favorite_at(&self.store, self.selection.selected()).map(|saved| saved.id); - let selected_position = favorites.iter().position(|saved| Some(saved.id) == selected); - let items: Vec = favorites.into_iter().map(glib::BoxedAnyObject::new).collect(); + let selected = self.tree.row(self.selection.selected()).as_ref().and_then(key_of); + self.expansion.reset_rows(); + self.expansion + .expanded + .borrow_mut() + .retain(|id| index.nodes.contains_key(&Key::Folder(*id))); + let items: Vec<_> = index + .children(None) + .iter() + .copied() + .map(glib::BoxedAnyObject::new) + .collect(); + self.index.replace(Rc::new(index)); self.store.splice(0, self.store.n_items(), &items); - self.selection - .set_selected(selected_position.map_or(gtk::INVALID_LIST_POSITION, |position| position as u32)); + self.expansion.updating.set(false); + self.expansion.observe(&self.tree); + self.selection.set_selected( + selected + .and_then(|key| position_of(&self.tree, key)) + .unwrap_or(gtk::INVALID_LIST_POSITION), + ); self.stale.set_revealed(false); + self.new_folder.set_sensitive(true); self.stack .set_visible_child_name(if items.is_empty() { EMPTY } else { LIST }); } + pub(crate) fn folder_destinations(&self) -> Vec<(i64, String)> { + self.index.borrow().destinations() + } + #[cfg(test)] pub(crate) fn ids(&self) -> Vec { - (0..self.store.n_items()) - .filter_map(|position| favorite_at(&self.store, position)) - .map(|favorite| favorite.id) - .collect() + self.index.borrow().queries().iter().map(|query| query.id).collect() } #[cfg(test)] pub(crate) fn names(&self) -> Vec { - (0..self.store.n_items()) - .filter_map(|position| favorite_at(&self.store, position)) - .map(|favorite| favorite.name) + self.index + .borrow() + .queries() + .into_iter() + .map(|query| query.name) .collect() } -} - -fn favorite_at(store: &gio::ListStore, position: u32) -> Option { - let item = store.item(position).and_downcast::()?; - Some(item.borrow::().clone()) -} - -fn factory() -> gtk::SignalListItemFactory { - let factory = gtk::SignalListItemFactory::new(); - factory.connect_setup(|_, item| { - let Some(item) = item.downcast_ref::() else { - return; - }; - let name = gtk::Label::builder() - .xalign(0.0) - .ellipsize(gtk::pango::EllipsizeMode::End) - .build(); - let summary = gtk::Label::builder() - .xalign(0.0) - .ellipsize(gtk::pango::EllipsizeMode::End) - .build(); - summary.add_css_class("caption"); - summary.add_css_class("dimmed"); - let labels = gtk::Box::builder() - .orientation(gtk::Orientation::Vertical) - .spacing(2) - .hexpand(true) - .valign(gtk::Align::Center) - .build(); - labels.append(&name); - labels.append(&summary); - let menu = gtk::MenuButton::builder() - .icon_name("view-more-symbolic") - .valign(gtk::Align::Center) - .build(); - menu.add_css_class("flat"); - let row = gtk::Box::builder().spacing(6).margin_top(6).margin_bottom(6).build(); - row.add_css_class(ROW); - row.append(&labels); - row.append(&menu); - item.set_child(Some(&row)); - }); - factory.connect_bind(move |_, item| { - let Some(item) = item.downcast_ref::() else { - return; - }; - let (Some(object), Some(row)) = (item.item().and_downcast::(), item.child()) else { - return; - }; - let favorite = object.borrow::().clone(); - row.set_widget_name(&favorite.id.to_string()); - if let Some(labels) = row.first_child() { - if let Some(name) = labels.first_child().and_downcast::() { - name.set_label(&favorite.name); - } - if let Some(summary) = labels.last_child().and_downcast::() { - summary.set_label(favorite.summary()); - summary.set_visible(!favorite.summary().is_empty()); - } - } - if let Some(menu) = row.last_child().and_downcast::() { - let label = gettext_f("Options for “{name}”", &[("name", &favorite.name)]); - menu.set_tooltip_text(Some(&label)); - menu.update_property(&[gtk::accessible::Property::Label(&label)]); - menu.set_menu_model(Some(&menu_of(favorite.id))); - } - item.set_accessible_label(&favorite.name); - }); - factory.connect_unbind(|_, item| { - let Some(row) = item.downcast_ref::().and_then(|item| item.child()) else { - return; - }; - row.set_widget_name(""); - if let Some(menu) = row.last_child().and_downcast::() { - menu.popdown(); - menu.set_menu_model(None::<&gio::MenuModel>); - } - }); - factory -} - -fn install_menu( - list: >k::ListView, - store: &gio::ListStore, - selection: >k::SingleSelection, - asked: &Asked, -) -> gtk::PopoverMenu { - let actions = gio::SimpleActionGroup::new(); - for (name, make) in [ - (RENAME, FavoriteAction::Rename as fn(SavedQuery) -> FavoriteAction), - (DELETE, FavoriteAction::Delete), - ] { - let action = gio::SimpleAction::new(name, Some(glib::VariantTy::INT64)); - let (store, asked) = (store.clone(), asked.clone()); - action.connect_activate(move |_, target| { - let Some(id) = target.and_then(|target| target.get::()) else { - return; - }; - if let Some(favorite) = favorite_by_id(&store, id) { - asked(make(favorite)); - } - }); - actions.add_action(&action); - } - list.insert_action_group("favorite", Some(&actions)); - let menu = gtk::PopoverMenu::from_model(None::<&gio::MenuModel>); - menu.set_has_arrow(false); - menu.set_parent(list); - let click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_SECONDARY).build(); - { - let (list, store, menu) = (list.downgrade(), store.clone(), menu.clone()); - click.connect_pressed(move |gesture, _, x, y| { - let Some(list) = list.upgrade() else { - return; - }; - let Some(favorite) = row_at(&list, &store, x, y) else { - return; - }; - gesture.set_state(gtk::EventSequenceState::Claimed); - menu.set_menu_model(Some(&menu_of(favorite.id))); - menu.set_pointing_to(Some(>k::gdk::Rectangle::new(x as i32, y as i32, 1, 1))); - menu.popup(); - }); + #[cfg(test)] + pub(crate) fn folder_of_first_query(&self) -> Option { + self.index.borrow().queries().first().and_then(|query| query.folder_id) } - list.add_controller(click); - // GTK requires manually parented popovers to leave before their parent is finalized. - list.connect_destroy({ - let menu = menu.clone(); - move |_| menu.unparent() - }); - - install_keys(list, store, selection, asked, &menu); - menu } -fn install_keys( - list: >k::ListView, - store: &gio::ListStore, - selection: >k::SingleSelection, - asked: &Asked, - menu: >k::PopoverMenu, -) { - let keys = gtk::EventControllerKey::new(); - keys.set_name(Some(KEYS)); - let (selection, store, asked, menu_for_key, list_weak) = ( - selection.clone(), - store.clone(), - asked.clone(), - menu.clone(), - list.downgrade(), - ); - keys.connect_key_pressed(move |_, key, _, modifiers| { - let modifiers = modifiers.intersection(gtk::accelerator_get_default_mod_mask()); - let Some(favorite) = favorite_at(&store, selection.selected()) else { - return glib::Propagation::Proceed; - }; - if (key == gtk::gdk::Key::Menu && modifiers.is_empty()) - || (key == gtk::gdk::Key::F10 && modifiers == gtk::gdk::ModifierType::SHIFT_MASK) - { - let Some(list) = list_weak.upgrade() else { - return glib::Propagation::Proceed; - }; - let bounds = find_row(&list, favorite.id).and_then(|row| row.compute_bounds(&list)); - let anchor = bounds.map(|bounds| { - gtk::gdk::Rectangle::new( - bounds.x() as i32, - bounds.y() as i32, - bounds.width() as i32, - bounds.height() as i32, - ) - }); - menu_for_key.set_menu_model(Some(&menu_of(favorite.id))); - menu_for_key.set_pointing_to(anchor.as_ref()); - menu_for_key.popup(); - return glib::Propagation::Stop; - } - if !modifiers.is_empty() { - return glib::Propagation::Proceed; - } - match key { - gtk::gdk::Key::F2 => asked(FavoriteAction::Rename(favorite)), - gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete => asked(FavoriteAction::Delete(favorite)), - _ => return glib::Propagation::Proceed, - } - glib::Propagation::Stop +fn status_pages(list: >k::ListView, retry: Rc) -> (gtk::Stack, adw::StatusPage, gtk::Button, adw::Banner) { + let retry_button = gtk::Button::with_label(&gettext("Try Again")); + retry_button.set_halign(gtk::Align::Center); + retry_button.connect_clicked({ + let retry = retry.clone(); + move |_| retry() }); - list.add_controller(keys); + let error = adw::StatusPage::builder() + .title(gettext("Favorites Unavailable")) + .icon_name("dialog-warning-symbolic") + .child(&retry_button) + .build(); + error.add_css_class("compact"); + let stale = adw::Banner::builder() + .title(gettext("Favorites could not be refreshed.")) + .button_label(gettext("Try Again")) + .build(); + stale.connect_button_clicked(move |_| retry()); + let content = gtk::Box::new(gtk::Orientation::Vertical, 0); + content.append(&stale); + content.append( + >k::ScrolledWindow::builder() + .hscrollbar_policy(gtk::PolicyType::Never) + .vexpand(true) + .child(list) + .build(), + ); + let empty = adw::StatusPage::builder() + .title(gettext("No Favorites")) + .icon_name("starred-symbolic") + .description(gettext( + "Save a query from the SQL editor or create a folder to organize favorites.", + )) + .build(); + empty.add_css_class("compact"); + let stack = gtk::Stack::builder().vexpand(true).build(); + stack.add_named(&content, Some(LIST)); + stack.add_named(&error, Some("error")); + let loading = adw::StatusPage::builder() + .title(gettext("Loading Favorites")) + .child(&adw::Spinner::new()) + .build(); + loading.add_css_class("compact"); + stack.add_named(&loading, Some("loading")); + let disconnected = adw::StatusPage::builder() + .title(gettext("No Connection Selected")) + .description(gettext("Open a connection to see its saved queries.")) + .icon_name("starred-symbolic") + .build(); + disconnected.add_css_class("compact"); + stack.add_named(&disconnected, Some("disconnected")); + stack.add_named(&empty, Some(EMPTY)); + stack.set_visible_child_name(EMPTY); + (stack, error, retry_button, stale) } -fn menu_of(id: i64) -> gio::Menu { - let menu = gio::Menu::new(); - for (label, action) in [(gettext("_Rename…"), RENAME), (gettext("_Delete…"), DELETE)] { - let item = gio::MenuItem::new(Some(&label), None); - item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&id.to_variant())); - menu.append_item(&item); +fn model_of(index: &Index, parent: Option) -> gio::ListStore { + let store = gio::ListStore::new::(); + for key in index.children(parent) { + store.append(&glib::BoxedAnyObject::new(*key)); } - menu + store } -fn favorite_by_id(store: &gio::ListStore, id: i64) -> Option { - (0..store.n_items()) - .filter_map(|position| favorite_at(store, position)) - .find(|favorite| favorite.id == id) +fn key_of(row: >k::TreeListRow) -> Option { + Some(*row.item().and_downcast::()?.borrow::()) } -fn row_at(list: >k::ListView, store: &gio::ListStore, x: f64, y: f64) -> Option { - let mut widget = list.pick(x, y, gtk::PickFlags::DEFAULT); - while let Some(candidate) = widget { - if candidate.has_css_class(ROW) { - return candidate - .widget_name() - .parse() - .ok() - .and_then(|id| favorite_by_id(store, id)); - } - widget = candidate.parent(); - } - None +fn position_of(tree: >k::TreeListModel, key: Key) -> Option { + (0..tree.n_items()).find(|position| tree.row(*position).as_ref().and_then(key_of) == Some(key)) } -fn find_row(widget: &impl IsA, id: i64) -> Option { - let widget = widget.as_ref(); - if widget.has_css_class(ROW) && widget.widget_name() == id.to_string() { - return Some(widget.clone()); - } - let mut child = widget.first_child(); - while let Some(current) = child { - if let Some(row) = find_row(¤t, id) { - return Some(row); - } - child = current.next_sibling(); - } - None +#[derive(Default)] +struct Expansion { + expanded: RefCell>, + watched: RefCell>, + updating: Cell, } -#[cfg(test)] -mod tests { - use super::*; - use std::time::SystemTime; - use uuid::Uuid; - - fn saved(id: i64, name: &str) -> SavedQuery { - SavedQuery { - id, - name: name.to_owned(), - query: "SELECT 1".to_owned(), - connection_id: Uuid::nil(), - connection_name: "Database".to_owned(), - created_at: SystemTime::UNIX_EPOCH, - updated_at: SystemTime::UNIX_EPOCH, +impl Expansion { + fn reset_rows(&self) { + self.updating.set(true); + for (_, (row, watch)) in self.watched.take() { + row.disconnect(watch); } } - #[gtk4::test] - fn favorites_keep_selection_by_id_after_rename_and_reorder() { - let pane = FavoritesPane::new(|_| {}, || {}); - pane.show(vec![saved(1, "One"), saved(2, "Two")]); - pane.selection.set_selected(1); - pane.show(vec![saved(2, "Renamed"), saved(1, "One")]); - assert_eq!(pane.selection.selected(), 0); - pane.show(vec![saved(1, "One")]); - assert_eq!(pane.selection.selected(), gtk::INVALID_LIST_POSITION); - } - - #[gtk4::test] - fn favorites_distinguish_loading_empty_unavailable_and_failed_refresh() { - let retried = Rc::new(std::cell::Cell::new(false)); - let retry = retried.clone(); - let pane = FavoritesPane::new(|_| {}, move || retry.set(true)); - pane.loading(); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some("loading")); - pane.failed(); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some("error")); - pane.retry.emit_clicked(); - assert!(retried.get()); - pane.show(vec![]); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some(EMPTY)); - pane.show(vec![saved(1, "One")]); - pane.failed(); - assert!(pane.stale.is_revealed()); - assert_eq!(pane.names(), ["One"]); - pane.unavailable(); - assert!(!pane.retry.is_visible()); - assert!(pane.names().is_empty()); - pane.no_connection(); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some("disconnected")); - } - - type Actions = Rc>>; - const WAIT: std::time::Duration = std::time::Duration::from_secs(30); - - fn shown() -> (FavoritesPane, crate::test_support::OwnedWindow, Actions) { - adw::init().expect("libadwaita"); - let actions = Actions::default(); - let sink = actions.clone(); - let pane = FavoritesPane::new(move |action| sink.borrow_mut().push(action), || {}); - pane.show(vec![saved(1, "One"), saved(2, "Two")]); - let window = gtk::Window::builder() - .default_width(360) - .default_height(360) - .child(&pane.widget()) - .build(); - let window = crate::test_support::OwnedWindow::presented(window); - crate::test_support::wait_until(WAIT, || find_row(&list(&pane), 2).is_some_and(|row| row.height() > 0)) - .expect("rows laid out"); - (pane, window, actions) - } - - fn list(pane: &FavoritesPane) -> gtk::ListView { - pane.menu - .parent() - .and_downcast::() - .expect("menu belongs to list") - } - - fn press(pane: &FavoritesPane, key: gtk::gdk::Key, modifiers: gtk::gdk::ModifierType) -> bool { - let controllers = list(pane).observe_controllers(); - let keys = (0..controllers.n_items()) - .filter_map(|position| controllers.item(position).and_downcast::()) - .find(|keys| keys.name().as_deref() == Some(KEYS)) - .expect("favorite key handler"); - keys.emit_by_name::("key-pressed", &[&key, &0u32, &modifiers]) - } - - fn target(menu: &impl IsA, position: i32) -> glib::Variant { - menu.as_ref() - .item_attribute_value(position, "target", None) - .expect("menu target") - } - - fn requested(actions: &Actions) -> Vec<(&'static str, i64, String)> { - actions - .borrow() - .iter() - .filter_map(|action| match action { - FavoriteAction::Rename(saved) => Some(("rename", saved.id, saved.name.clone())), - FavoriteAction::Delete(saved) => Some(("delete", saved.id, saved.name.clone())), - FavoriteAction::Open(_) => None, - }) - .collect() - } - - #[gtk4::test] - fn a_favorite_has_a_named_menu_button_that_acts_on_its_row() { - let (pane, _window, actions) = shown(); - let row = find_row(&list(&pane), 2).expect("second row"); - let button = row - .last_child() - .and_downcast::() - .expect("row menu button"); - assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); - assert_eq!(button.tooltip_text().as_deref(), Some("Options for “Two”")); - button.popup(); - assert!(button.popover().expect("row popover").is_visible()); - let menu = button.menu_model().expect("row menu"); - assert_eq!(menu.n_items(), 2); - crate::test_support::assert_access_keys(&menu); - let action = menu - .item_attribute_value(0, "action", None) - .and_then(|value| value.get::()) - .expect("rename action"); - button - .activate_action(&action, Some(&target(&menu, 0))) - .expect("rename from menu"); - assert_eq!(requested(&actions), [("rename", 2, "Two".to_owned())]); - } - - #[gtk4::test] - fn favorite_shortcuts_use_selection_and_ignore_modifiers() { - use gtk::gdk::{Key, ModifierType}; - let (pane, _window, actions) = shown(); - pane.selection.set_selected(1); - for modifier in [ - ModifierType::SHIFT_MASK, - ModifierType::CONTROL_MASK, - ModifierType::ALT_MASK, - ModifierType::SUPER_MASK, - ] { - for key in [Key::F2, Key::Delete, Key::KP_Delete] { - assert!(!press(&pane, key, modifier)); - } + fn observe(self: &Rc, tree: >k::TreeListModel) { + if self.updating.replace(true) { + return; } - assert!(actions.borrow().is_empty()); - assert!(press(&pane, Key::F2, ModifierType::empty())); - assert!(press(&pane, Key::Delete, ModifierType::empty())); - assert!(press(&pane, Key::KP_Delete, ModifierType::empty())); - assert_eq!( - requested(&actions), - [ - ("rename", 2, "Two".to_owned()), - ("delete", 2, "Two".to_owned()), - ("delete", 2, "Two".to_owned()), - ] - ); - pane.selection.set_selected(gtk::INVALID_LIST_POSITION); - assert!(!press(&pane, Key::F2, ModifierType::empty())); - } - - #[gtk4::test] - fn the_keyboard_opens_the_selected_favorites_context_menu() { - use gtk::gdk::{Key, ModifierType}; - let (pane, _window, actions) = shown(); - pane.selection.set_selected(1); - for (key, modifiers) in [(Key::F10, ModifierType::SHIFT_MASK), (Key::Menu, ModifierType::empty())] { - assert!(press(&pane, key, modifiers)); - assert!(pane.menu.is_visible()); - let model = pane.menu.menu_model().expect("context menu"); - let target = target(&model, 1); - assert_eq!(target.get::(), Some(2)); - pane.menu.popdown(); + let mut position = 0; + while position < tree.n_items() { + let Some(row) = tree.row(position) else { + break; + }; + position += 1; + let Some(Key::Folder(id)) = key_of(&row) else { + continue; + }; + if self.watched.borrow().get(&id).is_some_and(|(held, _)| held == &row) { + continue; + } + if let Some((old, watch)) = self.watched.borrow_mut().remove(&id) { + old.disconnect(watch); + } + let weak = Rc::downgrade(self); + let watch = row.connect_expanded_notify(move |row| { + let Some(state) = weak.upgrade().filter(|state| !state.updating.get()) else { + return; + }; + if row.is_expanded() { + state.expanded.borrow_mut().insert(id); + } else { + state.expanded.borrow_mut().remove(&id); + } + }); + let expanded = self.expanded.borrow().contains(&id); + self.watched.borrow_mut().insert(id, (row.clone(), watch)); + row.set_expanded(expanded); } - assert!(actions.borrow().is_empty()); - assert!(!press( - &pane, - Key::F10, - ModifierType::CONTROL_MASK | ModifierType::SHIFT_MASK - )); - } - - #[gtk4::test] - fn a_secondary_click_targets_the_clicked_favorite() { - let (pane, _window, actions) = shown(); - let list = list(&pane); - pane.selection.set_selected(0); - let row = find_row(&list, 2).expect("second row"); - let bounds = row.compute_bounds(&list).expect("row bounds"); - let controllers = list.observe_controllers(); - let click = (0..controllers.n_items()) - .filter_map(|position| controllers.item(position).and_downcast::()) - .find(|click| click.button() == gtk::gdk::BUTTON_SECONDARY) - .expect("secondary click"); - click.emit_by_name::<()>( - "pressed", - &[&1i32, &f64::from(bounds.x() + 4.0), &f64::from(bounds.y() + 4.0)], - ); - assert!(pane.menu.is_visible()); - let model = pane.menu.menu_model().expect("context menu"); - list.activate_action("favorite.delete", Some(&target(&model, 1))) - .expect("delete"); - assert_eq!(requested(&actions), [("delete", 2, "Two".to_owned())]); + self.updating.set(false); } +} - #[gtk4::test] - fn reordered_menu_targets_keep_their_id_and_removed_targets_do_nothing() { - let (pane, _window, actions) = shown(); - let list = list(&pane); - let previous = target(&menu_of(2), 0); - pane.selection.set_selected(1); - pane.show(vec![saved(2, "Renamed"), saved(1, "One")]); - list.activate_action("favorite.rename", Some(&previous)) - .expect("old action routed"); - assert_eq!(requested(&actions), [("rename", 2, "Renamed".to_owned())]); - assert!(press(&pane, gtk::gdk::Key::F2, gtk::gdk::ModifierType::empty())); - assert_eq!( - requested(&actions), - [("rename", 2, "Renamed".to_owned()), ("rename", 2, "Renamed".to_owned()),] - ); - let before_switch = target(&menu_of(2), 1); - pane.clear(); - list.activate_action("favorite.delete", Some(&before_switch)) - .expect("stale target routed"); - assert_eq!(actions.borrow().len(), 2); - pane.show(vec![saved(3, "Different connection")]); - list.activate_action("favorite.delete", Some(&before_switch)) - .expect("stale target routed"); - assert_eq!(actions.borrow().len(), 2); - let current = target(&menu_of(3), 1); - pane.show(vec![]); - list.activate_action("favorite.delete", Some(¤t)) - .expect("removed target routed"); - assert_eq!(actions.borrow().len(), 2); +impl Drop for Expansion { + fn drop(&mut self) { + self.reset_rows(); } } diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs new file mode 100644 index 0000000000..e4392d0060 --- /dev/null +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs @@ -0,0 +1,382 @@ +use super::rows::{find_row, menu_of}; +use super::*; +use std::time::SystemTime; +use uuid::Uuid; + +fn saved(id: i64, name: &str) -> SavedQuery { + SavedQuery { + id, + name: name.to_owned(), + query: "SELECT 1".to_owned(), + connection_id: Uuid::nil(), + connection_name: "Database".to_owned(), + keyword: None, + folder_id: None, + order: 0, + created_at: SystemTime::UNIX_EPOCH, + updated_at: SystemTime::UNIX_EPOCH, + } +} + +#[gtk4::test] +fn favorites_keep_selection_by_id_after_rename_and_reorder() { + let pane = FavoritesPane::new(|_| {}, || {}); + show(&pane, vec![saved(1, "One"), saved(2, "Two")]); + pane.selection.set_selected(1); + show(&pane, vec![saved(2, "Renamed"), saved(1, "One")]); + assert_eq!(pane.selection.selected(), 0); + show(&pane, vec![saved(1, "One")]); + assert_eq!(pane.selection.selected(), gtk::INVALID_LIST_POSITION); +} + +#[gtk4::test] +fn favorites_distinguish_loading_empty_unavailable_and_failed_refresh() { + let retried = Rc::new(std::cell::Cell::new(false)); + let retry = retried.clone(); + let pane = FavoritesPane::new(|_| {}, move || retry.set(true)); + pane.loading(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("loading")); + pane.failed(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("error")); + pane.retry.emit_clicked(); + assert!(retried.get()); + show(&pane, vec![]); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some(EMPTY)); + show(&pane, vec![saved(1, "One")]); + pane.failed(); + assert!(pane.stale.is_revealed()); + assert_eq!(pane.names(), ["One"]); + pane.unavailable(); + assert!(!pane.retry.is_visible()); + assert!(pane.names().is_empty()); + pane.no_connection(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("disconnected")); +} + +type Actions = Rc>>; +const WAIT: std::time::Duration = std::time::Duration::from_secs(30); + +fn shown() -> (FavoritesPane, crate::test_support::OwnedWindow, Actions) { + adw::init().expect("libadwaita"); + let actions = Actions::default(); + let sink = actions.clone(); + let pane = FavoritesPane::new(move |action| sink.borrow_mut().push(action), || {}); + show(&pane, vec![saved(1, "One"), saved(2, "Two")]); + let window = gtk::Window::builder() + .default_width(360) + .default_height(360) + .child(&pane.widget()) + .build(); + let window = crate::test_support::OwnedWindow::presented(window); + crate::test_support::wait_until(WAIT, || { + find_row(&list(&pane), Key::Query(2)).is_some_and(|row| row.height() > 0) + }) + .expect("rows laid out"); + (pane, window, actions) +} + +fn list(pane: &FavoritesPane) -> gtk::ListView { + pane.menu + .parent() + .and_downcast::() + .expect("menu belongs to list") +} + +fn press(pane: &FavoritesPane, key: gtk::gdk::Key, modifiers: gtk::gdk::ModifierType) -> bool { + let controllers = list(pane).observe_controllers(); + let keys = (0..controllers.n_items()) + .filter_map(|position| controllers.item(position).and_downcast::()) + .find(|keys| keys.name().as_deref() == Some(KEYS)) + .expect("favorite key handler"); + keys.emit_by_name::("key-pressed", &[&key, &0u32, &modifiers]) +} + +fn target(menu: &impl IsA, position: i32) -> glib::Variant { + menu.as_ref() + .item_attribute_value(position, "target", None) + .expect("menu target") +} + +fn requested(actions: &Actions) -> Vec<(&'static str, i64, String)> { + actions + .borrow() + .iter() + .filter_map(|action| match action { + FavoriteAction::Rename(saved) => Some(("rename", saved.id, saved.name.clone())), + FavoriteAction::Delete(saved) => Some(("delete", saved.id, saved.name.clone())), + _ => None, + }) + .collect() +} + +#[gtk4::test] +fn a_favorite_has_a_named_menu_button_that_acts_on_its_row() { + let (pane, _window, actions) = shown(); + let row = find_row(&list(&pane), Key::Query(2)).expect("second row"); + let button = row + .last_child() + .and_downcast::() + .expect("row menu button"); + assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); + assert_eq!(button.tooltip_text().as_deref(), Some("Options for “Two”")); + button.popup(); + assert!(button.popover().expect("row popover").is_visible()); + let menu = button.menu_model().expect("row menu"); + assert_eq!(menu.n_items(), 3); + crate::test_support::assert_access_keys(&menu); + let action = menu + .item_attribute_value(0, "action", None) + .and_then(|value| value.get::()) + .expect("rename action"); + button + .activate_action(&action, Some(&target(&menu, 0))) + .expect("rename from menu"); + assert_eq!(requested(&actions), [("rename", 2, "Two".to_owned())]); +} + +#[gtk4::test] +fn favorite_shortcuts_use_selection_and_ignore_modifiers() { + use gtk::gdk::{Key, ModifierType}; + let (pane, _window, actions) = shown(); + pane.selection.set_selected(1); + for modifier in [ + ModifierType::SHIFT_MASK, + ModifierType::CONTROL_MASK, + ModifierType::ALT_MASK, + ModifierType::SUPER_MASK, + ] { + for key in [Key::F2, Key::Delete, Key::KP_Delete] { + assert!(!press(&pane, key, modifier)); + } + } + assert!(actions.borrow().is_empty()); + assert!(press(&pane, Key::F2, ModifierType::empty())); + assert!(press(&pane, Key::Delete, ModifierType::empty())); + assert!(press(&pane, Key::KP_Delete, ModifierType::empty())); + assert_eq!( + requested(&actions), + [ + ("rename", 2, "Two".to_owned()), + ("delete", 2, "Two".to_owned()), + ("delete", 2, "Two".to_owned()), + ] + ); + pane.selection.set_selected(gtk::INVALID_LIST_POSITION); + assert!(!press(&pane, Key::F2, ModifierType::empty())); +} + +#[gtk4::test] +fn the_keyboard_opens_the_selected_favorites_context_menu() { + use gtk::gdk::{Key, ModifierType}; + let (pane, _window, actions) = shown(); + pane.selection.set_selected(1); + for (key, modifiers) in [(Key::F10, ModifierType::SHIFT_MASK), (Key::Menu, ModifierType::empty())] { + assert!(press(&pane, key, modifiers)); + assert!(pane.menu.is_visible()); + let model = pane.menu.menu_model().expect("context menu"); + let target = target(&model, 2); + assert_eq!(target.get::().as_deref(), Some("q2")); + pane.menu.popdown(); + } + assert!(actions.borrow().is_empty()); + assert!(!press( + &pane, + Key::F10, + ModifierType::CONTROL_MASK | ModifierType::SHIFT_MASK + )); +} + +#[gtk4::test] +fn a_secondary_click_targets_the_clicked_favorite() { + let (pane, _window, actions) = shown(); + let list = list(&pane); + pane.selection.set_selected(0); + let row = find_row(&list, Key::Query(2)).expect("second row"); + let bounds = row.compute_bounds(&list).expect("row bounds"); + let controllers = list.observe_controllers(); + let click = (0..controllers.n_items()) + .filter_map(|position| controllers.item(position).and_downcast::()) + .find(|click| click.button() == gtk::gdk::BUTTON_SECONDARY) + .expect("secondary click"); + click.emit_by_name::<()>( + "pressed", + &[&1i32, &f64::from(bounds.x() + 4.0), &f64::from(bounds.y() + 4.0)], + ); + assert!(pane.menu.is_visible()); + let model = pane.menu.menu_model().expect("context menu"); + list.activate_action("favorite.delete", Some(&target(&model, 2))) + .expect("delete"); + assert_eq!(requested(&actions), [("delete", 2, "Two".to_owned())]); +} + +#[gtk4::test] +fn reordered_menu_targets_keep_their_id_and_removed_targets_do_nothing() { + let (pane, _window, actions) = shown(); + let list = list(&pane); + let previous = target(&menu_of(Key::Query(2)), 0); + pane.selection.set_selected(1); + show(&pane, vec![saved(2, "Renamed"), saved(1, "One")]); + list.activate_action("favorite.rename", Some(&previous)) + .expect("old action routed"); + assert_eq!(requested(&actions), [("rename", 2, "Renamed".to_owned())]); + assert!(press(&pane, gtk::gdk::Key::F2, gtk::gdk::ModifierType::empty())); + assert_eq!( + requested(&actions), + [("rename", 2, "Renamed".to_owned()), ("rename", 2, "Renamed".to_owned()),] + ); + let before_switch = target(&menu_of(Key::Query(2)), 2); + pane.clear(); + list.activate_action("favorite.delete", Some(&before_switch)) + .expect("stale target routed"); + assert_eq!(actions.borrow().len(), 2); + show(&pane, vec![saved(3, "Different connection")]); + list.activate_action("favorite.delete", Some(&before_switch)) + .expect("stale target routed"); + assert_eq!(actions.borrow().len(), 2); + let current = target(&menu_of(Key::Query(3)), 2); + show(&pane, vec![]); + list.activate_action("favorite.delete", Some(¤t)) + .expect("removed target routed"); + assert_eq!(actions.borrow().len(), 2); +} + +fn show(pane: &FavoritesPane, mut queries: Vec) { + for (order, query) in queries.iter_mut().enumerate() { + query.order = order as i64; + } + pane.show(SavedQueriesSnapshot { + queries, + folders: vec![], + }); +} + +fn folder(id: i64, name: &str, parent_id: Option) -> SavedQueryFolder { + SavedQueryFolder { + id, + name: name.to_owned(), + parent_id, + connection_id: Uuid::nil(), + order: id, + created_at: SystemTime::UNIX_EPOCH, + updated_at: SystemTime::UNIX_EPOCH, + } +} + +fn nested_snapshot(name: &str) -> SavedQueriesSnapshot { + let mut query = saved(1, name); + query.folder_id = Some(3); + SavedQueriesSnapshot { + queries: vec![query], + folders: vec![ + folder(1, "Parent", None), + folder(2, "Child", Some(1)), + folder(3, "Nested", Some(2)), + ], + } +} + +fn tree_row(pane: &FavoritesPane, key: Key) -> gtk::TreeListRow { + pane.tree + .row(position_of(&pane.tree, key).expect("visible key")) + .expect("row") +} + +#[gtk4::test] +fn nested_expansion_and_selected_identity_survive_refresh_and_collapsed_ancestors() { + let pane = FavoritesPane::new(|_| {}, || {}); + pane.show(nested_snapshot("Before")); + assert_eq!(pane.tree.n_items(), 1); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + tree_row(&pane, Key::Folder(2)).set_expanded(true); + tree_row(&pane, Key::Folder(3)).set_expanded(true); + pane.selection + .set_selected(position_of(&pane.tree, Key::Query(1)).expect("query")); + pane.show(nested_snapshot("After")); + assert_eq!(pane.tree.n_items(), 4); + assert_eq!( + pane.tree.row(pane.selection.selected()).as_ref().and_then(key_of), + Some(Key::Query(1)) + ); + assert_eq!(pane.names(), ["After"]); + tree_row(&pane, Key::Folder(1)).set_expanded(false); + pane.show(nested_snapshot("After again")); + assert_eq!(pane.tree.n_items(), 1); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + assert!(tree_row(&pane, Key::Folder(2)).is_expanded()); + assert!(tree_row(&pane, Key::Folder(3)).is_expanded()); + assert_eq!(pane.tree.n_items(), 4); + pane.clear(); + pane.show(nested_snapshot("Different connection")); + assert_eq!(pane.tree.n_items(), 1); + assert_eq!(pane.selection.selected(), gtk::INVALID_LIST_POSITION); +} + +#[gtk4::test] +fn new_folder_requires_a_successful_read_and_an_invalid_graph_keeps_the_last_good_rows() { + let actions = Actions::default(); + let sink = actions.clone(); + let pane = FavoritesPane::new(move |action| sink.borrow_mut().push(action), || {}); + assert!(!pane.new_folder.is_sensitive()); + show(&pane, vec![]); + assert!(pane.new_folder.is_sensitive()); + pane.new_folder.emit_clicked(); + assert!(matches!(actions.borrow().as_slice(), [FavoriteAction::NewFolder(None)])); + pane.loading(); + assert!(!pane.new_folder.is_sensitive()); + pane.failed(); + assert!(!pane.new_folder.is_sensitive()); + pane.show(nested_snapshot("Kept")); + assert!(pane.new_folder.is_sensitive()); + let mut invalid = nested_snapshot("Lost"); + invalid.folders.clear(); + pane.show(invalid); + assert_eq!(pane.names(), ["Kept"]); + assert!(pane.stale.is_revealed()); + assert!(!pane.new_folder.is_sensitive()); + pane.no_connection(); + assert!(!pane.new_folder.is_sensitive()); +} + +#[gtk4::test] +fn folder_and_query_menus_use_distinct_ids_and_hidden_targets_do_nothing() { + let (pane, _window, actions) = shown(); + pane.show(nested_snapshot("Query")); + pane.selection.set_selected(0); + assert!(press(&pane, gtk::gdk::Key::F2, gtk::gdk::ModifierType::empty())); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::RenameFolder(folder)) if folder.id == 1)); + let list = list(&pane); + let menu = menu_of(Key::Folder(1)); + crate::test_support::assert_access_keys(&menu); + list.activate_action("favorite.new-folder", Some(&target(&menu, 0))) + .expect("new subfolder"); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::NewFolder(Some(folder))) if folder.id == 1)); + list.activate_action("favorite.delete", Some(&target(&menu, 2))) + .expect("delete folder"); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::DeleteFolder(folder)) if folder.id == 1)); + let query_menu = menu_of(Key::Query(1)); + let before = actions.borrow().len(); + list.activate_action("favorite.move", Some(&target(&query_menu, 1))) + .expect("hidden action routed"); + assert_eq!(actions.borrow().len(), before); + for id in [1, 2, 3] { + tree_row(&pane, Key::Folder(id)).set_expanded(true); + } + list.activate_action("favorite.move", Some(&target(&query_menu, 1))) + .expect("move query"); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::MoveTo(query)) if query.id == 1)); + crate::test_support::wait_until(WAIT, || { + find_row(&list, Key::Folder(1)).is_some_and(|row| row.height() > 0) + }) + .expect("folder visible"); + let row = find_row(&list, Key::Folder(1)).expect("folder row"); + let expander = row + .parent() + .and_downcast::() + .expect("native expander"); + assert_eq!(crate::test_support::assert_labelled(&expander), Ok(())); + let button = row + .last_child() + .and_downcast::() + .expect("folder menu button"); + assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); +} diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_rows.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_rows.rs new file mode 100644 index 0000000000..bd4701c540 --- /dev/null +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_rows.rs @@ -0,0 +1,340 @@ +use super::*; +use crate::i18n::gettext_f; + +pub(super) fn factory(index: SharedIndex) -> gtk::SignalListItemFactory { + let factory = gtk::SignalListItemFactory::new(); + factory.connect_setup(|_, item| setup(item)); + factory.connect_bind(move |_, item| bind(item, &index)); + factory.connect_unbind(|_, item| unbind(item)); + factory +} + +fn setup(item: &glib::Object) { + let Some(item) = item.downcast_ref::() else { + return; + }; + item.set_focusable(false); + let name = gtk::Label::builder() + .xalign(0.0) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + let summary = gtk::Label::builder() + .xalign(0.0) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + summary.add_css_class("caption"); + summary.add_css_class("dimmed"); + let labels = gtk::Box::builder() + .orientation(gtk::Orientation::Vertical) + .spacing(2) + .hexpand(true) + .valign(gtk::Align::Center) + .build(); + labels.append(&name); + labels.append(&summary); + let menu = gtk::MenuButton::builder() + .icon_name("view-more-symbolic") + .valign(gtk::Align::Center) + .build(); + menu.add_css_class("flat"); + let row = gtk::Box::builder().spacing(6).margin_top(6).margin_bottom(6).build(); + row.add_css_class(ROW); + row.append(>k::Image::from_icon_name("folder-symbolic")); + row.append(&labels); + row.append(&menu); + let expander = gtk::TreeExpander::new(); + expander.set_indent_for_icon(true); + expander.set_child(Some(&row)); + follow_expansion(&expander); + item.set_child(Some(&expander)); +} + +fn bind(item: &glib::Object, index: &SharedIndex) { + let Some(item) = item.downcast_ref::() else { + return; + }; + let (Some(tree_row), Some(expander)) = ( + item.item().and_downcast::(), + item.child().and_downcast::(), + ) else { + return; + }; + let index = index.borrow(); + let Some(node) = key_of(&tree_row).and_then(|key| index.nodes.get(&key)) else { + return; + }; + expander.set_list_row(Some(&tree_row)); + expander.set_hide_expander(matches!(node, Node::Folder(folder) if index.children(Some(folder.id)).is_empty())); + let Some(row) = expander.child() else { + return; + }; + row.set_widget_name(&node.key().target()); + if let Some(icon) = row.first_child().and_downcast::() { + icon.set_icon_name(Some(match node { + Node::Folder(_) => "folder-symbolic", + Node::Query(_) => "text-x-generic-symbolic", + })); + } + if let Some(labels) = row.first_child().and_then(|icon| icon.next_sibling()) { + if let Some(name) = labels.first_child().and_downcast::() { + name.set_label(node.name()); + } + if let Some(summary) = labels.last_child().and_downcast::() { + let text = match node { + Node::Folder(_) => "", + Node::Query(query) => query.summary(), + }; + summary.set_label(text); + summary.set_visible(!text.is_empty()); + } + } + if let Some(menu) = row.last_child().and_downcast::() { + let label = gettext_f("Options for “{name}”", &[("name", node.name())]); + menu.set_tooltip_text(Some(&label)); + menu.update_property(&[gtk::accessible::Property::Label(&label)]); + menu.set_menu_model(Some(&menu_of(node.key()))); + } + let label = accessible_label(node, &index); + item.set_accessible_label(&label); + expander.update_property(&[gtk::accessible::Property::Label(&label)]); +} + +fn unbind(item: &glib::Object) { + let Some(expander) = item + .downcast_ref::() + .and_then(|item| item.child()) + .and_downcast::() + else { + return; + }; + if let Some(row) = expander.child() { + row.set_widget_name(""); + if let Some(menu) = row.last_child().and_downcast::() { + menu.popdown(); + menu.set_menu_model(None::<&gio::MenuModel>); + } + } + expander.set_list_row(None); + expander.update_property(&[gtk::accessible::Property::Label("")]); +} + +fn accessible_label(node: &Node, index: &Index) -> String { + let label = match node { + Node::Folder(_) => gettext_f("Folder “{name}”", &[("name", node.name())]), + Node::Query(_) => gettext_f("Saved query “{name}”", &[("name", node.name())]), + }; + match node.parent().and_then(|parent| index.path(parent)) { + Some(path) => gettext_f("{item} in {folder}", &[("item", &label), ("folder", path)]), + None => label, + } +} + +fn follow_expansion(expander: >k::TreeExpander) { + // GTK updates the arrow's expanded state; the row's accessible node needs it too. + let watched: Rc>> = Rc::default(); + expander.connect_list_row_notify({ + let watched = watched.clone(); + move |expander| { + if let Some((row, watch)) = watched.take() { + row.disconnect(watch); + } + let Some(row) = expander.list_row().filter(|row| row.is_expandable()) else { + expander.update_state(&[gtk::accessible::State::Expanded(None)]); + return; + }; + expander.update_state(&[gtk::accessible::State::Expanded(Some(row.is_expanded()))]); + let weak = expander.downgrade(); + let watch = row.connect_expanded_notify(move |row| { + if let Some(expander) = weak.upgrade() { + expander.update_state(&[gtk::accessible::State::Expanded(Some(row.is_expanded()))]); + } + }); + watched.replace(Some((row, watch))); + } + }); + expander.connect_destroy(move |_| { + if let Some((row, watch)) = watched.take() { + row.disconnect(watch); + } + }); +} + +pub(super) fn install_menu( + list: >k::ListView, + tree: >k::TreeListModel, + index: &SharedIndex, + selection: >k::SingleSelection, + asked: &Asked, +) -> gtk::PopoverMenu { + let actions = gio::SimpleActionGroup::new(); + for name in [RENAME, DELETE, MOVE, NEW_FOLDER] { + let action = gio::SimpleAction::new(name, Some(glib::VariantTy::STRING)); + let (tree, index, asked) = (tree.clone(), index.clone(), asked.clone()); + action.connect_activate(move |_, target| { + let Some(key) = target + .and_then(|target| target.get::()) + .as_deref() + .and_then(Key::parse) + else { + return; + }; + if position_of(&tree, key).is_none() { + return; + } + if let Some(node) = index.borrow().nodes.get(&key).cloned() { + request(&asked, name, node); + } + }); + actions.add_action(&action); + } + list.insert_action_group("favorite", Some(&actions)); + let menu = gtk::PopoverMenu::from_model(None::<&gio::MenuModel>); + menu.set_has_arrow(false); + menu.set_parent(list); + let click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_SECONDARY).build(); + click.connect_pressed({ + let (list, index, menu) = (list.downgrade(), index.clone(), menu.clone()); + move |gesture, _, x, y| { + let Some(list) = list.upgrade() else { + return; + }; + let Some(key) = row_at(&list, &index, x, y) else { + return; + }; + gesture.set_state(gtk::EventSequenceState::Claimed); + menu.set_menu_model(Some(&menu_of(key))); + menu.set_pointing_to(Some(>k::gdk::Rectangle::new(x as i32, y as i32, 1, 1))); + menu.popup(); + } + }); + list.add_controller(click); + // A manually parented popover must leave before its parent is finalized. + list.connect_destroy({ + let menu = menu.clone(); + move |_| menu.unparent() + }); + install_keys(list, tree, index, selection, asked, &menu); + menu +} + +fn request(asked: &Asked, name: &str, node: Node) { + let action = match (name, node) { + (RENAME, Node::Query(query)) => FavoriteAction::Rename(query), + (DELETE, Node::Query(query)) => FavoriteAction::Delete(query), + (MOVE, Node::Query(query)) => FavoriteAction::MoveTo(query), + (RENAME, Node::Folder(folder)) => FavoriteAction::RenameFolder(folder), + (DELETE, Node::Folder(folder)) => FavoriteAction::DeleteFolder(folder), + (NEW_FOLDER, Node::Folder(folder)) => FavoriteAction::NewFolder(Some(folder)), + _ => return, + }; + asked(action); +} + +fn install_keys( + list: >k::ListView, + tree: >k::TreeListModel, + index: &SharedIndex, + selection: >k::SingleSelection, + asked: &Asked, + menu: >k::PopoverMenu, +) { + let keys = gtk::EventControllerKey::new(); + keys.set_name(Some(KEYS)); + let (selection, tree, index, asked, menu, list_weak) = ( + selection.clone(), + tree.clone(), + index.clone(), + asked.clone(), + menu.clone(), + list.downgrade(), + ); + keys.connect_key_pressed(move |_, key, _, modifiers| { + let modifiers = modifiers.intersection(gtk::accelerator_get_default_mod_mask()); + let Some(row_key) = tree.row(selection.selected()).as_ref().and_then(key_of) else { + return glib::Propagation::Proceed; + }; + let Some(node) = index.borrow().nodes.get(&row_key).cloned() else { + return glib::Propagation::Proceed; + }; + if (key == gtk::gdk::Key::Menu && modifiers.is_empty()) + || (key == gtk::gdk::Key::F10 && modifiers == gtk::gdk::ModifierType::SHIFT_MASK) + { + let Some(list) = list_weak.upgrade() else { + return glib::Propagation::Proceed; + }; + let anchor = find_row(&list, row_key) + .and_then(|row| row.compute_bounds(&list)) + .map(|bounds| { + gtk::gdk::Rectangle::new( + bounds.x() as i32, + bounds.y() as i32, + bounds.width() as i32, + bounds.height() as i32, + ) + }); + menu.set_menu_model(Some(&menu_of(row_key))); + menu.set_pointing_to(anchor.as_ref()); + menu.popup(); + return glib::Propagation::Stop; + } + if !modifiers.is_empty() { + return glib::Propagation::Proceed; + } + match key { + gtk::gdk::Key::F2 => request(&asked, RENAME, node), + gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete => request(&asked, DELETE, node), + _ => return glib::Propagation::Proceed, + } + glib::Propagation::Stop + }); + list.add_controller(keys); +} + +pub(super) fn menu_of(key: Key) -> gio::Menu { + let menu = gio::Menu::new(); + let entries = match key { + Key::Query(_) => [ + (gettext("_Rename…"), RENAME), + (gettext("_Move to Folder…"), MOVE), + (gettext("_Delete…"), DELETE), + ], + Key::Folder(_) => [ + (gettext("New _Subfolder…"), NEW_FOLDER), + (gettext("_Rename…"), RENAME), + (gettext("_Delete…"), DELETE), + ], + }; + for (label, action) in entries { + let item = gio::MenuItem::new(Some(&label), None); + item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&key.target().to_variant())); + menu.append_item(&item); + } + menu +} + +fn row_at(list: >k::ListView, index: &SharedIndex, x: f64, y: f64) -> Option { + let mut widget = list.pick(x, y, gtk::PickFlags::DEFAULT); + while let Some(candidate) = widget { + if candidate.has_css_class(ROW) { + let key = Key::parse(&candidate.widget_name())?; + return index.borrow().nodes.contains_key(&key).then_some(key); + } + widget = candidate.parent(); + } + None +} + +pub(super) fn find_row(widget: &impl IsA, key: Key) -> Option { + let widget = widget.as_ref(); + if widget.has_css_class(ROW) && widget.widget_name() == key.target() { + return Some(widget.clone()); + } + let mut child = widget.first_child(); + while let Some(current) = child { + if let Some(row) = find_row(¤t, key) { + return Some(row); + } + child = current.next_sibling(); + } + None +} diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 709de48cfb..3a154c6688 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -381,8 +381,6 @@ mod tests { wait_until(WAIT, || favorites.names().is_empty()).expect("the favorite to go"); } - /// Favorites are filed in folders: a folder is made, a query moved into - /// it, and deleting the folder leaves the query. #[gtk4::test] fn favorites_are_filed_in_folders_and_a_deleted_folder_leaves_its_queries() { use gtk4::subclass::prelude::ObjectSubclassIsExt; @@ -398,13 +396,29 @@ mod tests { wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); shell.create_folder("Reports".to_owned(), None); - wait_until(WAIT, || favorites.folders().len() == 1).expect("the folder to be listed"); - let folder = favorites.folders()[0].id; - shell.move_favorite(favorites.ids()[0], Some(folder)); - wait_until(WAIT, || favorites.folder_of_first_query() == Some(folder)).expect("the query filed in it"); + wait_until(WAIT, || favorites.folder_destinations().len() == 1).expect("the folder to be listed"); + let folder = favorites.folder_destinations()[0].0; + let store = test.services.history().store().expect("history").saved_query_folders(); + let owner = test.workspace().connection_id().expect("connection"); + let work = test + .services + .tasks + .spawn_task(async move { store.create(owner, "Monthly", Some(folder)).await }); + let child = finish_on_main(WAIT, work) + .expect("created") + .expect("task") + .expect("folder"); + wait_until(WAIT, || favorites.folder_destinations().len() == 2).expect("external folder listed"); + assert!( + favorites + .folder_destinations() + .contains(&(child, "/Reports/Monthly".to_owned())) + ); + shell.move_favorite(favorites.ids()[0], Some(child)); + wait_until(WAIT, || favorites.folder_of_first_query() == Some(child)).expect("the query filed in it"); shell.delete_folder(folder); - wait_until(WAIT, || favorites.folders().is_empty()).expect("the folder to go"); + wait_until(WAIT, || favorites.folder_destinations().is_empty()).expect("the folder to go"); assert_eq!(favorites.names(), ["Orders"], "the query went with its folder"); assert_eq!(favorites.folder_of_first_query(), None); } diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index ffd6710feb..0e95841776 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -11,8 +11,8 @@ use gtk4::subclass::prelude::*; use libadwaita as adw; use libadwaita::prelude::{AdwDialogExt, AlertDialogExt, BinExt, PreferencesGroupExt}; use tablepro_core::DataModel; -use tablepro_storage::SavedQueries; use tablepro_storage::saved_queries::SavedQuery; +use tablepro_storage::{QueryHistory, SavedQueriesSnapshot}; use uuid::Uuid; use super::health_banner::REVIEW_HOST_KEY; @@ -37,7 +37,7 @@ const FAVORITES: &str = "favorites"; pub(super) const SHOW_ASSISTANT: &str = "show-assistant"; type FavoritesRead = Result< - Option, tablepro_storage::StorageError>>, + Option>, tablepro_session::runtime::TaskFailure, >; @@ -642,7 +642,7 @@ impl WorkspaceShell { tasks, async move { let history = ready.await?; - Some(history.saved_queries().list(Some(connection)).await) + Some(history.saved_queries().snapshot(connection).await) }, glib::clone!( #[weak(rename_to = shell)] @@ -681,6 +681,10 @@ impl WorkspaceShell { } FavoriteAction::Rename(favorite) => self.ask_favorite_name(favorite), FavoriteAction::Delete(favorite) => self.ask_favorite_deletion(favorite), + FavoriteAction::MoveTo(favorite) => self.ask_folder_for(favorite), + FavoriteAction::NewFolder(parent) => self.ask_folder_name(parent, None), + FavoriteAction::RenameFolder(folder) => self.ask_folder_name(None, Some(folder)), + FavoriteAction::DeleteFolder(folder) => self.ask_folder_deletion(folder), } } @@ -735,21 +739,32 @@ impl WorkspaceShell { pub(crate) fn rename_favorite(&self, id: i64, name: String) { self.change_favorites( - async move |store| store.rename(id, &name).await, + async move |history| history.saved_queries().rename(id, &name).await, gettext("Could not rename that saved query."), ); } pub(crate) fn delete_favorite(&self, id: i64) { self.change_favorites( - async move |store| store.delete(id).await, + async move |history| history.saved_queries().delete(id).await, gettext("Could not delete that saved query."), ); } - fn change_favorites(&self, change: impl FnOnce(SavedQueries) -> W + Send + 'static, failure: String) + pub(super) fn change_favorites(&self, change: impl FnOnce(QueryHistory) -> W + Send + 'static, failure: String) where W: std::future::Future> + Send + 'static, + { + self.change_favorites_with(change, failure, favorite_failure_text); + } + + pub(super) fn change_favorites_with( + &self, + change: impl FnOnce(QueryHistory) -> W + Send + 'static, + failure: String, + describe: fn(&tablepro_storage::StorageError, &str) -> String, + ) where + W: std::future::Future> + Send + 'static, { let imp = self.imp(); let Some((history, tasks)) = imp.favorites_source.get() else { @@ -762,7 +777,7 @@ impl WorkspaceShell { let (send, received) = tokio::sync::oneshot::channel(); crate::runtime::spawn_held(tasks, hold.as_ref(), async move { let result = match ready.await { - Some(history) => change(history.saved_queries()).await, + Some(history) => change(history).await, None => Err(tablepro_storage::StorageError::NotInitialised), }; let _ = send.send(result); @@ -777,7 +792,7 @@ impl WorkspaceShell { Ok(Ok(())) => return, Ok(Err(error)) => { tracing::warn!(%error, "could not change a favorite"); - favorite_failure_text(&error, &failure) + describe(&error, &failure) } Err(error) => { tracing::warn!(%error, "favorite change did not finish"); @@ -1113,7 +1128,7 @@ mod tests { shell.change_favorites( move |store| async move { released.await.expect("release write"); - store.rename(id, "After close").await + store.saved_queries().rename(id, "After close").await }, "Rename failed".to_owned(), ); @@ -1224,18 +1239,49 @@ mod tests { query: "SELECT 1".to_owned(), connection_id: connection, connection_name: "Database".to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: std::time::SystemTime::UNIX_EPOCH, updated_at: std::time::SystemTime::UNIX_EPOCH, }; - shell.favorites_arrived(current, connection, Ok(Some(Ok(vec![saved.clone()])))); + shell.favorites_arrived( + current, + connection, + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![saved.clone()], + folders: vec![], + }))), + ); let pane = shell.imp().favorites.get().expect("pane"); - shell.favorites_arrived(old, connection, Ok(Some(Ok(vec![])))); + shell.favorites_arrived( + old, + connection, + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![], + folders: vec![], + }))), + ); assert_eq!(pane.names(), ["Current"]); - shell.favorites_arrived(current, Uuid::new_v4(), Ok(Some(Ok(vec![])))); + shell.favorites_arrived( + current, + Uuid::new_v4(), + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![], + folders: vec![], + }))), + ); assert_eq!(pane.names(), ["Current"]); shell.set_front(None); assert!(pane.names().is_empty()); - shell.favorites_arrived(current, connection, Ok(Some(Ok(vec![saved])))); + shell.favorites_arrived( + current, + connection, + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![saved], + folders: vec![], + }))), + ); assert!(pane.names().is_empty()); } diff --git a/linux/docs/storage.md b/linux/docs/storage.md index 5e3d780028..857556b407 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -269,14 +269,13 @@ can tell whether a re-pinned entry falls in the pages already read. ### Following the saved queries -`SavedQueries::changes` is a watch of a revision that every handle of one -database shares. A save, a save of a new name, a rename, a delete and a -connection's queries going move it on once they landed; a read, and a write -that changed nothing, leave it. The sidebar's Favorites and the Saved Queries -dialog read again on each revision, so a write from any window, an import or -a deleted connection reaches every list. Each list rejects replies from an -older read and keeps selection by saved-query id. Confirmed saves, renames -and deletions hold the process until the write finishes. +The Favorites sidebar and Saved Queries dialog follow the shared revision +feed from one `QueryHistory` ([core ADR 0017](../../core/docs/decisions/0017-favourites.md)). +A write from any window, an import or a deleted connection refreshes every list. +The sidebar reads queries and folders as one snapshot. Each list rejects replies +from an older read. Selection and folder expansion stay with their record IDs +during a refresh and clear when the front connection changes. Confirmed saves, +renames, moves and deletions hold the process until the write finishes. The editor first inserts without replacement and asks for confirmation if the name is taken. Confirmed replacement updates the same row id. The existence check diff --git a/linux/po/POTFILES.in b/linux/po/POTFILES.in index 3f0065ec44..c01ba7dfa1 100644 --- a/linux/po/POTFILES.in +++ b/linux/po/POTFILES.in @@ -609,6 +609,7 @@ crates/app/src/ui/workspace/database_transfer.rs crates/app/src/ui/workspace/definitions.rs crates/app/src/ui/workspace/diagram.rs crates/app/src/ui/workspace/editor_label.rs +crates/app/src/ui/workspace/favorite_folders.rs crates/app/src/ui/workspace/finished_work.rs crates/app/src/ui/workspace/health_banner.rs crates/app/src/ui/workspace/imp.rs @@ -621,7 +622,10 @@ crates/app/src/ui/workspace/saves.rs crates/app/src/ui/workspace/session_watches.rs crates/app/src/ui/workspace/sidebar/catalog_watch.rs crates/app/src/ui/workspace/sidebar/connection_tree.rs +crates/app/src/ui/workspace/sidebar/favorites_index.rs crates/app/src/ui/workspace/sidebar/favorites_pane.rs +crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs +crates/app/src/ui/workspace/sidebar/favorites_rows.rs crates/app/src/ui/workspace/sidebar/key_listing.rs crates/app/src/ui/workspace/sidebar/mod.rs crates/app/src/ui/workspace/sidebar/object_key.rs From 0a56e20c77d3c84b0fc924d0ef553af0635f4e48 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 02:49:04 +0700 Subject: [PATCH 23/23] fix(linux-sidebar): preserve nested expansion and selection positions --- .../ui/workspace/sidebar/favorites_pane.rs | 18 ++++++++----- .../workspace/sidebar/favorites_pane_tests.rs | 26 +++++++++++++++++++ 2 files changed, 38 insertions(+), 6 deletions(-) diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 8b77141998..723722ed8c 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -71,6 +71,14 @@ impl FavoritesPane { } }); let expansion = Rc::new(Expansion::default()); + + let selection = gtk::SingleSelection::builder() + .model(&tree) + .autoselect(false) + .can_unselect(true) + .build(); + let list = gtk::ListView::new(Some(selection.clone()), Some(rows::factory(index.clone()))); + // Selection and view must process an insertion before restoring expansion emits nested insertions. tree.connect_items_changed({ let expansion = Rc::downgrade(&expansion); move |tree, _, _, _| { @@ -79,12 +87,6 @@ impl FavoritesPane { } } }); - let selection = gtk::SingleSelection::builder() - .model(&tree) - .autoselect(false) - .can_unselect(true) - .build(); - let list = gtk::ListView::new(Some(selection.clone()), Some(rows::factory(index.clone()))); list.add_css_class("navigation-sidebar"); list.set_single_click_activate(true); list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); @@ -351,6 +353,10 @@ impl Expansion { } let weak = Rc::downgrade(self); let watch = row.connect_expanded_notify(move |row| { + // Collapsing an ancestor detaches its rows and emits false without changing the user's choice. + if !row.is_expandable() { + return; + } let Some(state) = weak.upgrade().filter(|state| !state.updating.get()) else { return; }; diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs index e4392d0060..69018fff0c 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs @@ -380,3 +380,29 @@ fn folder_and_query_menus_use_distinct_ids_and_hidden_targets_do_nothing() { .expect("folder menu button"); assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); } + +#[gtk4::test] +fn reopening_an_expanded_subtree_keeps_a_selected_root_siblings_position() { + let pane = FavoritesPane::new(|_| {}, || {}); + let mut snapshot = nested_snapshot("Filed query"); + snapshot.queries.push(saved(2, "Root query")); + pane.show(snapshot); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + tree_row(&pane, Key::Folder(2)).set_expanded(true); + let selected = Key::Query(2); + pane.selection + .set_selected(position_of(&pane.tree, selected).expect("root query")); + tree_row(&pane, Key::Folder(1)).set_expanded(false); + assert_eq!(pane.selection.selected(), 1); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + assert!(tree_row(&pane, Key::Folder(2)).is_expanded()); + assert_eq!( + pane.selection.selected(), + position_of(&pane.tree, selected).expect("selected query") + ); + assert_eq!(pane.selection.selected(), 3); + assert_eq!( + pane.tree.row(pane.selection.selected()).as_ref().and_then(key_of), + Some(selected) + ); +}