From 277106219b4c24135165b68afd152d1c5fc86a49 Mon Sep 17 00:00:00 2001 From: ZhuchkaTriplesix Date: Sun, 15 Nov 2026 14:31:58 +0300 Subject: [PATCH 1/2] feat(tauri): Postgres schema folders + typed SqlGuard IPC (#1977) Mirror Flutter pg tree under each schema (Tables/Views/Functions/ Sequences/Indexes/Triggers/Types) and serialize SqlGuardRule as a typed enum so the UI can branch before #1885 NeedsConfirmation. --- apps/tauri/src-tauri/src/connection/error.rs | 11 +- .../tauri/src-tauri/src/connection/manager.rs | 2 +- .../src-tauri/src/connection/object_tree.rs | 234 ++++++++++++-- .../src/connection/postgres_object_tree.rs | 303 ++++++++++++++++-- .../src-tauri/src/connection/sql_guard.rs | 11 +- .../src/connection/sqlite_object_tree.rs | 11 +- apps/tauri/src/api/connection.ts | 50 ++- apps/tauri/src/stores/objectTree.ts | 15 +- apps/tauri/src/stores/shellNav.ts | 2 +- apps/tauri/src/ui/ConnectionHome.vue | 11 +- apps/tauri/src/ui/ConnectionsPanel.vue | 7 +- apps/tauri/src/ui/QuickSwitcher.vue | 4 +- apps/tauri/src/ui/SqlObjectTreeNodes.vue | 26 +- 13 files changed, 605 insertions(+), 82 deletions(-) diff --git a/apps/tauri/src-tauri/src/connection/error.rs b/apps/tauri/src-tauri/src/connection/error.rs index a3bbb538..a5da31d3 100644 --- a/apps/tauri/src-tauri/src/connection/error.rs +++ b/apps/tauri/src-tauri/src/connection/error.rs @@ -13,8 +13,11 @@ pub enum ConnectionError { UnsupportedDriver { driver: DriverKind }, Io { message: String }, Driver { driver: DriverKind, message: String }, - /// sqlparser / product SQL guard refusal (`rule` is a stable id). - SqlGuard { rule: String, message: String }, + /// sqlparser / product SQL guard refusal (typed `rule` for UI branching). + SqlGuard { + rule: super::sql_guard::SqlGuardRule, + message: String, + }, } impl ConnectionError { @@ -42,7 +45,7 @@ impl ConnectionError { message: impl Into, ) -> Self { Self::SqlGuard { - rule: rule.as_str().to_owned(), + rule, message: message.into(), } } @@ -63,7 +66,7 @@ impl fmt::Display for ConnectionError { write!(f, "{driver} error: {message}") } Self::SqlGuard { rule, message } => { - write!(f, "sql guard ({rule}): {message}") + write!(f, "sql guard ({}): {message}", rule.as_str()) } } } diff --git a/apps/tauri/src-tauri/src/connection/manager.rs b/apps/tauri/src-tauri/src/connection/manager.rs index 5e4d19c6..f85905ae 100644 --- a/apps/tauri/src-tauri/src/connection/manager.rs +++ b/apps/tauri/src-tauri/src/connection/manager.rs @@ -432,7 +432,7 @@ mod tests { .unwrap_err(); match err { ConnectionError::SqlGuard { rule, .. } => { - assert_eq!(rule, "single_statement"); + assert_eq!(rule.as_str(), "single_statement"); } other => panic!("expected SqlGuard, got {other:?}"), } diff --git a/apps/tauri/src-tauri/src/connection/object_tree.rs b/apps/tauri/src-tauri/src/connection/object_tree.rs index 4f1b768d..3ca0f2b5 100644 --- a/apps/tauri/src-tauri/src/connection/object_tree.rs +++ b/apps/tauri/src-tauri/src/connection/object_tree.rs @@ -1,4 +1,4 @@ -//! Driver-agnostic SQL object tree (schemas → tables/views → columns). +//! Driver-agnostic SQL object tree (schemas → folders → objects → columns). use super::error::{ConnectionError, ConnectionResult}; use super::id::DriverKind; @@ -10,39 +10,111 @@ use serde::{Deserialize, Serialize}; #[serde(rename_all = "snake_case")] pub enum SqlObjectKind { Schema, + /// Virtual group under a schema (Tables, Functions, Indexes, …). + Folder, Table, View, + MaterializedView, Column, Index, Trigger, Function, Procedure, + Sequence, + /// User-defined type (enum / composite / domain / range). + #[serde(rename = "type")] + Type, +} + +/// Schema-level folder keys (Flutter `connections_panel_pg_tree` parity). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum SchemaFolderKind { + Tables, + Views, + MaterializedViews, + Functions, + Sequences, + Indexes, + Triggers, + Types, +} + +impl SchemaFolderKind { + pub fn as_str(self) -> &'static str { + match self { + Self::Tables => "tables", + Self::Views => "views", + Self::MaterializedViews => "materialized_views", + Self::Functions => "functions", + Self::Sequences => "sequences", + Self::Indexes => "indexes", + Self::Triggers => "triggers", + Self::Types => "types", + } + } + + pub fn label(self) -> &'static str { + match self { + Self::Tables => "Tables", + Self::Views => "Views", + Self::MaterializedViews => "Materialized views", + Self::Functions => "Functions", + Self::Sequences => "Sequences", + Self::Indexes => "Indexes", + Self::Triggers => "Triggers", + Self::Types => "Types", + } + } + + pub fn parse(s: &str) -> Option { + Self::ALL.into_iter().find(|folder| folder.as_str() == s) + } + + pub const ALL: [Self; 8] = [ + Self::Tables, + Self::Views, + Self::MaterializedViews, + Self::Functions, + Self::Sequences, + Self::Indexes, + Self::Triggers, + Self::Types, + ]; } impl SqlObjectKind { pub fn as_str(self) -> &'static str { match self { Self::Schema => "schema", + Self::Folder => "folder", Self::Table => "table", Self::View => "view", + Self::MaterializedView => "materialized_view", Self::Column => "column", Self::Index => "index", Self::Trigger => "trigger", Self::Function => "function", Self::Procedure => "procedure", + Self::Sequence => "sequence", + Self::Type => "type", } } fn parse(s: &str) -> Option { match s { "schema" => Some(Self::Schema), + "folder" => Some(Self::Folder), "table" => Some(Self::Table), "view" => Some(Self::View), + "materialized_view" => Some(Self::MaterializedView), "column" => Some(Self::Column), "index" => Some(Self::Index), "trigger" => Some(Self::Trigger), "function" => Some(Self::Function), "procedure" => Some(Self::Procedure), + "sequence" => Some(Self::Sequence), + "type" => Some(Self::Type), _ => None, } } @@ -50,12 +122,19 @@ impl SqlObjectKind { pub fn is_expandable(self) -> bool { matches!( self, - Self::Schema | Self::Table | Self::View | Self::Index | Self::Function | Self::Procedure + Self::Schema + | Self::Folder + | Self::Table + | Self::View + | Self::MaterializedView ) } pub fn is_relation(self) -> bool { - matches!(self, Self::Table | Self::View) + matches!( + self, + Self::Table | Self::View | Self::MaterializedView + ) } } @@ -127,6 +206,15 @@ pub fn schema_id(driver: DriverKind, schema: &str) -> String { format!("{}:schema:{}", driver.as_str(), enc_segment(schema)) } +pub fn folder_id(driver: DriverKind, schema: &str, folder: SchemaFolderKind) -> String { + format!( + "{}:folder:{}:{}", + driver.as_str(), + enc_segment(schema), + folder.as_str() + ) +} + pub fn relation_id(driver: DriverKind, kind: SqlObjectKind, schema: &str, name: &str) -> String { debug_assert!(kind.is_relation()); format!( @@ -148,6 +236,40 @@ pub fn column_id(driver: DriverKind, schema: &str, table: &str, column: &str) -> ) } +/// Schema-scoped object (function / sequence / type / …). +pub fn named_object_id( + driver: DriverKind, + kind: SqlObjectKind, + schema: &str, + name: &str, +) -> String { + format!( + "{}:{}:{}:{}", + driver.as_str(), + kind.as_str(), + enc_segment(schema), + enc_segment(name) + ) +} + +/// Index or trigger scoped to a relation: `driver:kind:schema:table:name`. +pub fn relation_child_id( + driver: DriverKind, + kind: SqlObjectKind, + schema: &str, + table: &str, + name: &str, +) -> String { + format!( + "{}:{}:{}:{}:{}", + driver.as_str(), + kind.as_str(), + enc_segment(schema), + enc_segment(table), + enc_segment(name) + ) +} + /// Parsed object id. #[derive(Debug, Clone, PartialEq, Eq)] pub enum ParsedObjectId { @@ -155,6 +277,11 @@ pub enum ParsedObjectId { driver: DriverKind, schema: String, }, + Folder { + driver: DriverKind, + schema: String, + folder: SchemaFolderKind, + }, Relation { driver: DriverKind, kind: SqlObjectKind, @@ -167,23 +294,42 @@ pub enum ParsedObjectId { table: String, column: String, }, + /// Function / sequence / type / procedure under a schema. + Named { + driver: DriverKind, + kind: SqlObjectKind, + schema: String, + name: String, + }, + /// Index / trigger under a relation. + RelationChild { + driver: DriverKind, + kind: SqlObjectKind, + schema: String, + table: String, + name: String, + }, } fn bad_id(msg: impl Into) -> ConnectionError { ConnectionError::invalid_config(msg) } +fn parse_driver(s: &str) -> ConnectionResult { + match s { + "sqlite" => Ok(DriverKind::Sqlite), + "postgres" => Ok(DriverKind::Postgres), + "mysql" => Ok(DriverKind::Mysql), + other => Err(bad_id(format!("unknown driver in object id: {other}"))), + } +} + pub fn parse_object_id(id: &str) -> ConnectionResult { let parts: Vec<&str> = id.split(':').collect(); if parts.len() < 3 { return Err(bad_id(format!("invalid object id: {id}"))); } - let driver = match parts[0] { - "sqlite" => DriverKind::Sqlite, - "postgres" => DriverKind::Postgres, - "mysql" => DriverKind::Mysql, - other => return Err(bad_id(format!("unknown driver in object id: {other}"))), - }; + let driver = parse_driver(parts[0])?; let kind = SqlObjectKind::parse(parts[1]) .ok_or_else(|| bad_id(format!("unknown object kind in id: {id}")))?; @@ -192,7 +338,18 @@ pub fn parse_object_id(id: &str) -> ConnectionResult { driver, schema: dec_segment(parts[2]), }), - SqlObjectKind::Table | SqlObjectKind::View if parts.len() == 4 => { + SqlObjectKind::Folder if parts.len() == 4 => { + let folder = SchemaFolderKind::parse(parts[3]) + .ok_or_else(|| bad_id(format!("unknown folder kind in id: {id}")))?; + Ok(ParsedObjectId::Folder { + driver, + schema: dec_segment(parts[2]), + folder, + }) + } + SqlObjectKind::Table | SqlObjectKind::View | SqlObjectKind::MaterializedView + if parts.len() == 4 => + { Ok(ParsedObjectId::Relation { driver, kind, @@ -206,15 +363,29 @@ pub fn parse_object_id(id: &str) -> ConnectionResult { table: dec_segment(parts[3]), column: dec_segment(parts[4]), }), - SqlObjectKind::Schema => Err(bad_id(format!("invalid schema id: {id}"))), - SqlObjectKind::Table | SqlObjectKind::View => { - Err(bad_id(format!("invalid relation id: {id}"))) + SqlObjectKind::Function + | SqlObjectKind::Procedure + | SqlObjectKind::Sequence + | SqlObjectKind::Type + if parts.len() == 4 => + { + Ok(ParsedObjectId::Named { + driver, + kind, + schema: dec_segment(parts[2]), + name: dec_segment(parts[3]), + }) + } + SqlObjectKind::Index | SqlObjectKind::Trigger if parts.len() == 5 => { + Ok(ParsedObjectId::RelationChild { + driver, + kind, + schema: dec_segment(parts[2]), + table: dec_segment(parts[3]), + name: dec_segment(parts[4]), + }) } - SqlObjectKind::Column => Err(bad_id(format!("invalid column id: {id}"))), - other => Err(bad_id(format!( - "object kind {:?} not supported in ids yet", - other - ))), + _ => Err(bad_id(format!("invalid object id: {id}"))), } } @@ -253,4 +424,31 @@ mod tests { other => panic!("unexpected {other:?}"), } } + + #[test] + fn folder_and_function_ids_round_trip() { + let fid = folder_id(DriverKind::Postgres, "shop", SchemaFolderKind::Functions); + assert_eq!(fid, "postgres:folder:shop:functions"); + match parse_object_id(&fid).unwrap() { + ParsedObjectId::Folder { folder, schema, .. } => { + assert_eq!(schema, "shop"); + assert_eq!(folder, SchemaFolderKind::Functions); + } + other => panic!("unexpected {other:?}"), + } + + let fn_id = named_object_id( + DriverKind::Postgres, + SqlObjectKind::Function, + "shop", + "total_orders", + ); + match parse_object_id(&fn_id).unwrap() { + ParsedObjectId::Named { kind, name, .. } => { + assert_eq!(kind, SqlObjectKind::Function); + assert_eq!(name, "total_orders"); + } + other => panic!("unexpected {other:?}"), + } + } } diff --git a/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs b/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs index 1a8b3514..d57e981d 100644 --- a/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs +++ b/apps/tauri/src-tauri/src/connection/postgres_object_tree.rs @@ -1,15 +1,20 @@ -//! Postgres object tree: schemas → tables/views → columns. +//! Postgres object tree: schemas → folders → objects (Flutter pg tree parity). use super::error::{ConnectionError, ConnectionResult}; use super::id::DriverKind; use super::introspect::{ColumnMeta, TableSchema}; use super::object_tree::{ - column_id, parse_object_id, relation_id, schema_id, ObjectTreeProvider, ParsedObjectId, - SqlObjectKind, SqlObjectNode, + column_id, folder_id, named_object_id, parse_object_id, relation_child_id, relation_id, + schema_id, ObjectTreeProvider, ParsedObjectId, SchemaFolderKind, SqlObjectKind, SqlObjectNode, }; use super::postgres::PostgresSession; use super::runtime; use sqlx::Row; +use std::fmt::Display; + +fn postgres_err(e: impl Display) -> ConnectionError { + ConnectionError::driver(DriverKind::Postgres, e.to_string()) +} pub struct PostgresObjectTree { session: PostgresSession, @@ -26,14 +31,19 @@ impl ObjectTreeProvider for PostgresObjectTree { match parent_id { None => self.list_schemas(), Some(pid) => match parse_object_id(pid)? { - ParsedObjectId::Schema { schema, .. } => self.list_relations(&schema), + ParsedObjectId::Schema { schema, .. } => self.list_schema_folders(&schema), + ParsedObjectId::Folder { schema, folder, .. } => { + self.list_folder_children(&schema, folder) + } ParsedObjectId::Relation { kind, schema, name, .. } => self.list_columns_nodes(kind, &schema, &name), - ParsedObjectId::Column { .. } => Ok(vec![]), + ParsedObjectId::Column { .. } + | ParsedObjectId::Named { .. } + | ParsedObjectId::RelationChild { .. } => Ok(vec![]), }, } } @@ -62,7 +72,7 @@ impl PostgresObjectTree { ) .fetch_all(pool) .await - .map_err(|e| ConnectionError::driver(DriverKind::Postgres, e.to_string()))?; + .map_err(postgres_err)?; Ok(rows .into_iter() @@ -81,35 +91,144 @@ impl PostgresObjectTree { }) } - fn list_relations(&self, schema: &str) -> ConnectionResult> { + fn list_schema_folders(&self, schema: &str) -> ConnectionResult> { + let parent = schema_id(DriverKind::Postgres, schema); + Ok(SchemaFolderKind::ALL + .into_iter() + .map(|folder| { + SqlObjectNode::new( + folder_id(DriverKind::Postgres, schema, folder), + folder.label().to_owned(), + SqlObjectKind::Folder, + Some(schema.to_owned()), + Some(parent.clone()), + ) + }) + .collect()) + } + + fn list_folder_children( + &self, + schema: &str, + folder: SchemaFolderKind, + ) -> ConnectionResult> { + match folder { + SchemaFolderKind::Tables => self.list_relations(schema, RelationFilter::Tables), + SchemaFolderKind::Views => self.list_relations(schema, RelationFilter::Views), + SchemaFolderKind::MaterializedViews => { + self.list_relations(schema, RelationFilter::MaterializedViews) + } + SchemaFolderKind::Functions => self.list_named_objects( + schema, + "SELECT DISTINCT p.proname + FROM pg_proc p + JOIN pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = $1 + AND p.prokind IN ('f', 'a', 'w') + ORDER BY p.proname", + SchemaFolderKind::Functions, + SqlObjectKind::Function, + ), + SchemaFolderKind::Sequences => self.list_named_objects( + schema, + "SELECT c.relname + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 AND c.relkind = 'S' + ORDER BY c.relname", + SchemaFolderKind::Sequences, + SqlObjectKind::Sequence, + ), + SchemaFolderKind::Indexes => self.list_relation_children( + schema, + "SELECT c.relname::text, i.relname::text + FROM pg_index x + JOIN pg_class c ON c.oid = x.indrelid + JOIN pg_class i ON i.oid = x.indexrelid + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind IN ('r', 'm', 'p') + ORDER BY c.relname, i.relname", + SchemaFolderKind::Indexes, + SqlObjectKind::Index, + ), + SchemaFolderKind::Triggers => self.list_relation_children( + schema, + "SELECT c.relname::text, t.tgname::text + FROM pg_trigger t + JOIN pg_class c ON c.oid = t.tgrelid + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND NOT t.tgisinternal + ORDER BY c.relname, t.tgname", + SchemaFolderKind::Triggers, + SqlObjectKind::Trigger, + ), + SchemaFolderKind::Types => self.list_named_objects( + schema, + "SELECT t.typname::text + FROM pg_type t + JOIN pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = $1 + AND t.typtype IN ('c', 'd', 'e', 'r', 'm') + ORDER BY t.typname", + SchemaFolderKind::Types, + SqlObjectKind::Type, + ), + } + } + + fn list_relations( + &self, + schema: &str, + filter: RelationFilter, + ) -> ConnectionResult> { let schema_owned = schema.to_owned(); + let sql = match filter { + RelationFilter::Tables => { + "SELECT c.relname, c.relkind::text + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind IN ('r', 'p') + AND NOT c.relispartition + ORDER BY c.relname" + } + RelationFilter::Views => { + "SELECT c.relname, c.relkind::text + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind = 'v' + ORDER BY c.relname" + } + RelationFilter::MaterializedViews => { + "SELECT c.relname, c.relkind::text + FROM pg_class c + JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = $1 + AND c.relkind = 'm' + ORDER BY c.relname" + } + }; self.session.with_pool(|pool| { runtime::block_on(async { - let rows = sqlx::query( - "SELECT c.relname, - CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'view' ELSE 'table' END - FROM pg_class c - JOIN pg_namespace n ON n.oid = c.relnamespace - WHERE n.nspname = $1 - AND c.relkind IN ('r', 'p', 'v', 'm') - AND NOT c.relispartition - ORDER BY c.relname", - ) - .bind(&schema_owned) - .fetch_all(pool) - .await - .map_err(|e| ConnectionError::driver(DriverKind::Postgres, e.to_string()))?; + let rows = sqlx::query(sql) + .bind(&schema_owned) + .fetch_all(pool) + .await + .map_err(postgres_err)?; - let parent = schema_id(DriverKind::Postgres, &schema_owned); + let parent = folder_id(DriverKind::Postgres, &schema_owned, filter.folder()); Ok(rows .into_iter() .map(|r| { let name: String = r.get(0); - let kind_s: String = r.get(1); - let kind = if kind_s == "view" { - SqlObjectKind::View - } else { - SqlObjectKind::Table + let relkind: String = r.get(1); + let kind = match relkind.as_str() { + "v" => SqlObjectKind::View, + "m" => SqlObjectKind::MaterializedView, + _ => SqlObjectKind::Table, }; SqlObjectNode::new( relation_id(DriverKind::Postgres, kind, &schema_owned, &name), @@ -124,6 +243,82 @@ impl PostgresObjectTree { }) } + fn list_named_objects( + &self, + schema: &str, + sql: &str, + folder: SchemaFolderKind, + kind: SqlObjectKind, + ) -> ConnectionResult> { + let schema_owned = schema.to_owned(); + self.session.with_pool(|pool| { + runtime::block_on(async { + let rows = sqlx::query(sql) + .bind(&schema_owned) + .fetch_all(pool) + .await + .map_err(postgres_err)?; + + let parent = folder_id(DriverKind::Postgres, &schema_owned, folder); + Ok(rows + .into_iter() + .map(|r| { + let name: String = r.get(0); + SqlObjectNode::new( + named_object_id(DriverKind::Postgres, kind, &schema_owned, &name), + name, + kind, + Some(schema_owned.clone()), + Some(parent.clone()), + ) + }) + .collect()) + }) + }) + } + + fn list_relation_children( + &self, + schema: &str, + sql: &str, + folder: SchemaFolderKind, + kind: SqlObjectKind, + ) -> ConnectionResult> { + let schema_owned = schema.to_owned(); + self.session.with_pool(|pool| { + runtime::block_on(async { + let rows = sqlx::query(sql) + .bind(&schema_owned) + .fetch_all(pool) + .await + .map_err(postgres_err)?; + + let parent = folder_id(DriverKind::Postgres, &schema_owned, folder); + Ok(rows + .into_iter() + .map(|r| { + let table: String = r.get(0); + let name: String = r.get(1); + let label = format!("{table}.{name}"); + SqlObjectNode::new( + relation_child_id( + DriverKind::Postgres, + kind, + &schema_owned, + &table, + &name, + ), + label, + kind, + Some(schema_owned.clone()), + Some(parent.clone()), + ) + }) + .collect()) + }) + }) + } + fn list_columns_nodes( &self, kind: SqlObjectKind, @@ -181,13 +376,10 @@ impl PostgresObjectTree { .bind(&table) .fetch_all(pool) .await - .map_err(|e| ConnectionError::driver(DriverKind::Postgres, e.to_string()))?; + .map_err(postgres_err)?; if rows.is_empty() { - return Err(ConnectionError::driver( - DriverKind::Postgres, - format!("relation {schema}.{table} not found"), - )); + return Err(postgres_err(format!("relation {schema}.{table} not found"))); } let mut columns = Vec::with_capacity(rows.len()); @@ -227,6 +419,22 @@ impl PostgresObjectTree { } } +enum RelationFilter { + Tables, + Views, + MaterializedViews, +} + +impl RelationFilter { + fn folder(self) -> SchemaFolderKind { + match self { + Self::Tables => SchemaFolderKind::Tables, + Self::Views => SchemaFolderKind::Views, + Self::MaterializedViews => SchemaFolderKind::MaterializedViews, + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -257,13 +465,38 @@ mod tests { let schemas = tree.list_children(None).expect("schemas"); assert!(schemas.iter().any(|s| s.name == "shop")); let shop = schemas.iter().find(|s| s.name == "shop").unwrap(); - let rels = tree.list_children(Some(&shop.id)).expect("rels"); - assert!(rels.iter().any(|r| r.name == "customers")); - let customers = rels.iter().find(|r| r.name == "customers").unwrap(); + + let folders = tree.list_children(Some(&shop.id)).expect("folders"); + let names: Vec<_> = folders.iter().map(|f| f.name.as_str()).collect(); + assert!(names.contains(&"Tables")); + assert!(names.contains(&"Functions")); + assert!(names.contains(&"Indexes")); + assert!(names.contains(&"Triggers")); + assert!(folders.iter().all(|f| f.kind == SqlObjectKind::Folder)); + + let tables_folder = folders.iter().find(|f| f.name == "Tables").unwrap(); + let tables = tree.list_children(Some(&tables_folder.id)).expect("tables"); + assert!(tables.iter().any(|r| r.name == "customers")); + + let customers = tables.iter().find(|r| r.name == "customers").unwrap(); let cols = tree.list_children(Some(&customers.id)).expect("cols"); assert!(cols.iter().any(|c| c.name == "id")); let desc = tree.describe(&customers.id).expect("describe"); assert!(desc.primary_keys.iter().any(|k| k == "id")); + + let fn_folder = folders.iter().find(|f| f.name == "Functions").unwrap(); + let functions = tree.list_children(Some(&fn_folder.id)).expect("functions"); + assert!( + !functions.is_empty(), + "shop schema should expose functions in the tree" + ); + assert!(functions.iter().all(|f| f.kind == SqlObjectKind::Function)); + + let idx_folder = folders.iter().find(|f| f.name == "Indexes").unwrap(); + let indexes = tree.list_children(Some(&idx_folder.id)).expect("indexes"); + assert!(indexes.iter().any(|i| i.name.contains("customers"))); + assert!(indexes.iter().all(|i| i.kind == SqlObjectKind::Index)); + session.disconnect().ok(); } } diff --git a/apps/tauri/src-tauri/src/connection/sql_guard.rs b/apps/tauri/src-tauri/src/connection/sql_guard.rs index e9c61a6d..f730e915 100644 --- a/apps/tauri/src-tauri/src/connection/sql_guard.rs +++ b/apps/tauri/src-tauri/src/connection/sql_guard.rs @@ -18,6 +18,15 @@ pub enum SqlGuardRule { Parse, } +impl serde::Serialize for SqlGuardRule { + fn serialize(&self, serializer: S) -> Result + where + S: serde::Serializer, + { + serializer.serialize_str(self.as_str()) + } +} + impl SqlGuardRule { pub fn as_str(self) -> &'static str { match self { @@ -89,7 +98,7 @@ mod tests { fn block_rule(sql: &str, driver: DriverKind, rule: SqlGuardRule) { let err = assert_single_statement(sql, driver).expect_err("expected block"); match err { - ConnectionError::SqlGuard { rule: r, .. } => assert_eq!(r, rule.as_str()), + ConnectionError::SqlGuard { rule: r, .. } => assert_eq!(r, rule), other => panic!("expected SqlGuard, got {other:?}"), } } diff --git a/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs b/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs index 94bb3984..134d5cb3 100644 --- a/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs +++ b/apps/tauri/src-tauri/src/connection/sqlite_object_tree.rs @@ -31,7 +31,10 @@ impl ObjectTreeProvider for SqliteObjectTree { ParsedObjectId::Relation { schema, name, .. } => { self.list_columns(&schema, &name, id) } - ParsedObjectId::Column { .. } => Ok(vec![]), + ParsedObjectId::Column { .. } + | ParsedObjectId::Folder { .. } + | ParsedObjectId::Named { .. } + | ParsedObjectId::RelationChild { .. } => Ok(vec![]), }, } } @@ -39,9 +42,9 @@ impl ObjectTreeProvider for SqliteObjectTree { fn describe(&self, object_id: &str) -> ConnectionResult { match parse_object_id(object_id)? { ParsedObjectId::Relation { name, .. } => self.session.list_columns(&name), - ParsedObjectId::Schema { .. } | ParsedObjectId::Column { .. } => Err( - ConnectionError::invalid_config("describe requires a table or view id"), - ), + _ => Err(ConnectionError::invalid_config( + "describe requires a table or view id", + )), } } } diff --git a/apps/tauri/src/api/connection.ts b/apps/tauri/src/api/connection.ts index 80665a41..74c3cdeb 100644 --- a/apps/tauri/src/api/connection.ts +++ b/apps/tauri/src/api/connection.ts @@ -10,13 +10,17 @@ export type SchemaObject = { export type SqlObjectKind = | "schema" + | "folder" | "table" | "view" + | "materialized_view" | "column" | "index" | "trigger" | "function" - | "procedure"; + | "procedure" + | "sequence" + | "type"; /** Stable tree node from `db_list_children`. */ export type SqlObjectNode = { @@ -28,6 +32,19 @@ export type SqlObjectNode = { expandable: boolean; }; +/** Mirrors Rust `ConnectionError` (serde tag = kind). */ +export type SqlGuardRule = "empty_query" | "single_statement" | "parse_error"; + +export type ConnectionError = + | { kind: "not_found"; id: string } + | { kind: "already_connected"; id: string } + | { kind: "disconnected"; id: string } + | { kind: "invalid_config"; message: string } + | { kind: "unsupported_driver"; driver: string } + | { kind: "io"; message: string } + | { kind: "driver"; driver: string; message: string } + | { kind: "sql_guard"; rule: SqlGuardRule; message: string }; + export type ColumnMeta = { name: string; data_type: string; @@ -193,16 +210,35 @@ export async function dbSqliteOverview(id: string): Promise { return invoke("db_sqlite_overview", { id }); } +export function isConnectionError(err: unknown): err is ConnectionError { + return ( + !!err && + typeof err === "object" && + typeof (err as { kind?: unknown }).kind === "string" + ); +} + export function formatConnectionError(err: unknown): string { if (typeof err === "string") return err; + if (isConnectionError(err)) { + switch (err.kind) { + case "sql_guard": + return `sql_guard: ${err.rule}: ${err.message}`; + case "driver": + return `${err.driver}: ${err.message}`; + case "not_found": + case "already_connected": + case "disconnected": + return `${err.kind}: ${err.id}`; + case "unsupported_driver": + return `unsupported_driver: ${err.driver}`; + case "invalid_config": + case "io": + return `${err.kind}: ${err.message}`; + } + } if (err && typeof err === "object") { const e = err as Record; - if (typeof e.kind === "string") { - const parts = [e.kind, e.driver, e.message, e.id].filter( - (v): v is string => typeof v === "string" && v.length > 0, - ); - return parts.join(": "); - } if (typeof e.message === "string") return e.message; } return String(err); diff --git a/apps/tauri/src/stores/objectTree.ts b/apps/tauri/src/stores/objectTree.ts index 254d7040..5a9e85a9 100644 --- a/apps/tauri/src/stores/objectTree.ts +++ b/apps/tauri/src/stores/objectTree.ts @@ -74,13 +74,22 @@ export function filterTree(nodes: TreeUiNode[], q: string): TreeUiNode[] { return out; } +function isRelationKind( + kind: TreeUiNode["kind"], +): kind is "table" | "view" | "materialized_view" { + return kind === "table" || kind === "view" || kind === "materialized_view"; +} + +/** Collect tables/views under schemas (and Postgres folder groups). */ function relationsOf(roots: TreeUiNode[]): TreeUiNode[] { const out: TreeUiNode[] = []; - for (const root of roots) { - for (const child of root.children ?? []) { - if (child.kind === "table" || child.kind === "view") out.push(child); + function walk(nodes: TreeUiNode[]) { + for (const n of nodes) { + if (isRelationKind(n.kind)) out.push(n); + if (n.children) walk(n.children); } } + walk(roots); return out; } diff --git a/apps/tauri/src/stores/shellNav.ts b/apps/tauri/src/stores/shellNav.ts index ea7a8f1c..4ce32b95 100644 --- a/apps/tauri/src/stores/shellNav.ts +++ b/apps/tauri/src/stores/shellNav.ts @@ -10,7 +10,7 @@ export type ObjectStripTab = "data" | "relations"; export type SelectedObject = { connectionId: string; name: string; - kind: "table" | "view"; + kind: "table" | "view" | "materialized_view"; /** Stable object id when known (`sqlite:table:main:users`). */ objectId?: string; schema?: string | null; diff --git a/apps/tauri/src/ui/ConnectionHome.vue b/apps/tauri/src/ui/ConnectionHome.vue index b32cb4a1..53ab5d43 100644 --- a/apps/tauri/src/ui/ConnectionHome.vue +++ b/apps/tauri/src/ui/ConnectionHome.vue @@ -27,7 +27,9 @@ const tables = computed(() => tree.relations.filter((o) => o.kind === "table"), ); const views = computed(() => - tree.relations.filter((o) => o.kind === "view"), + tree.relations.filter( + (o) => o.kind === "view" || o.kind === "materialized_view", + ), ); const overview = ref(null); @@ -119,7 +121,12 @@ watch( function openRelation(o: { id: string; name: string; kind: string; schema?: string | null }) { if (!conn.value) return; - if (o.kind !== "table" && o.kind !== "view") return; + if ( + o.kind !== "table" && + o.kind !== "view" && + o.kind !== "materialized_view" + ) + return; nav.selectObject({ connectionId: conn.value.id, name: o.name, diff --git a/apps/tauri/src/ui/ConnectionsPanel.vue b/apps/tauri/src/ui/ConnectionsPanel.vue index 4b25b60f..ff4e93b3 100644 --- a/apps/tauri/src/ui/ConnectionsPanel.vue +++ b/apps/tauri/src/ui/ConnectionsPanel.vue @@ -157,7 +157,12 @@ function onFolderExpand(id: string, e: MouseEvent) { } function onRelationClick(connectionId: string, node: TreeUiNode) { - if (node.kind !== "table" && node.kind !== "view") return; + if ( + node.kind !== "table" && + node.kind !== "view" && + node.kind !== "materialized_view" + ) + return; connections.select(connectionId); nav.selectObject({ connectionId, diff --git a/apps/tauri/src/ui/QuickSwitcher.vue b/apps/tauri/src/ui/QuickSwitcher.vue index 16c27eb1..a7ab7a5f 100644 --- a/apps/tauri/src/ui/QuickSwitcher.vue +++ b/apps/tauri/src/ui/QuickSwitcher.vue @@ -19,7 +19,7 @@ const input = ref(null); type Hit = { connectionId: string; name: string; - kind: "table" | "view"; + kind: "table" | "view" | "materialized_view"; connectionName: string; }; @@ -38,7 +38,7 @@ const hits = computed(() => { out.push({ connectionId: c.id, name: o.name, - kind: o.kind as "table" | "view", + kind: o.kind as "table" | "view" | "materialized_view", connectionName: c.name, }); } diff --git a/apps/tauri/src/ui/SqlObjectTreeNodes.vue b/apps/tauri/src/ui/SqlObjectTreeNodes.vue index 31a93194..967ae71d 100644 --- a/apps/tauri/src/ui/SqlObjectTreeNodes.vue +++ b/apps/tauri/src/ui/SqlObjectTreeNodes.vue @@ -18,8 +18,22 @@ function kindGlyph(kind: TreeUiNode["kind"]): string { switch (kind) { case "schema": return "▣"; + case "folder": + return "▸"; case "view": + case "materialized_view": return "◌"; + case "function": + case "procedure": + return "ƒ"; + case "sequence": + return "#"; + case "index": + return "⌘"; + case "trigger": + return "⚡"; + case "type": + return "T"; case "column": return "·"; default: @@ -27,8 +41,10 @@ function kindGlyph(kind: TreeUiNode["kind"]): string { } } -function isRelation(kind: TreeUiNode["kind"]): kind is "table" | "view" { - return kind === "table" || kind === "view"; +function isRelation( + kind: TreeUiNode["kind"], +): kind is "table" | "view" | "materialized_view" { + return kind === "table" || kind === "view" || kind === "materialized_view"; } function isSelected( @@ -74,7 +90,11 @@ function isSelected(