diff --git a/.cargo/config.toml b/.cargo/config.toml deleted file mode 100644 index 7624b335..00000000 --- a/.cargo/config.toml +++ /dev/null @@ -1,3 +0,0 @@ -[alias] -snap = "insta test" -xtask = "run --package xtask --" diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..43994f87 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "postgrestools.bin": "./target/debug/postgrestools" +} diff --git a/Cargo.lock b/Cargo.lock index 8844e46b..032c60af 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1456,9 +1456,9 @@ checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" [[package]] name = "globset" -version = "0.4.15" +version = "0.4.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15f1ce686646e7f1e19bf7d5533fe443a45dbfb990e00629110797578b42fb19" +checksum = "54a1028dfc5f5df5da8a56a73e6c153c9a9708ec57232470703592a3f18e49f5" dependencies = [ "aho-corasick", "bstr", @@ -2412,16 +2412,6 @@ dependencies = [ "tracing-tree", ] -[[package]] -name = "pgt_commands" -version = "0.0.0" -dependencies = [ - "anyhow", - "async-std", - "pgt_text_size", - "sqlx", -] - [[package]] name = "pgt_completions" version = "0.0.0" @@ -2578,6 +2568,7 @@ dependencies = [ "serde", "serde_json", "sqlx", + "strum", "tokio", "tower", "tower-lsp", @@ -2749,6 +2740,7 @@ dependencies = [ "biome_rowan", "dashmap 5.5.3", "futures", + "globset", "ignore", "pgt_analyse", "pgt_analyser", @@ -2767,6 +2759,7 @@ dependencies = [ "serde", "serde_json", "sqlx", + "strum", "tempfile", "tokio", "tracing", @@ -3309,6 +3302,12 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "rustversion" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2" + [[package]] name = "ryu" version = "1.0.18" @@ -3816,6 +3815,28 @@ version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" +[[package]] +name = "strum" +version = "0.27.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.27.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8" +dependencies = [ + "heck 0.5.0", + "proc-macro2", + "quote", + "rustversion", + "syn 2.0.90", +] + [[package]] name = "subtle" version = "2.6.1" diff --git a/Cargo.toml b/Cargo.toml index dc175660..3fcbf7f6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,6 +39,7 @@ serde = "1.0.195" serde_json = "1.0.114" similar = "2.6.0" smallvec = { version = "1.13.2", features = ["union", "const_new", "serde"] } +strum = { version = "0.27.1", features = ["derive"] } # this will use tokio if available, otherwise async-std sqlx = { version = "0.8.2", features = ["runtime-tokio", "runtime-async-std", "postgres", "json"] } syn = "1.0.109" @@ -56,7 +57,6 @@ pgt_analyse = { path = "./crates/pgt_analyse", version = "0.0.0" pgt_analyser = { path = "./crates/pgt_analyser", version = "0.0.0" } pgt_base_db = { path = "./crates/pgt_base_db", version = "0.0.0" } pgt_cli = { path = "./crates/pgt_cli", version = "0.0.0" } -pgt_commands = { path = "./crates/pgt_commands", version = "0.0.0" } pgt_completions = { path = "./crates/pgt_completions", version = "0.0.0" } pgt_configuration = { path = "./crates/pgt_configuration", version = "0.0.0" } pgt_console = { path = "./crates/pgt_console", version = "0.0.0" } diff --git a/crates/pgt_commands/Cargo.toml b/crates/pgt_commands/Cargo.toml deleted file mode 100644 index 31b6d589..00000000 --- a/crates/pgt_commands/Cargo.toml +++ /dev/null @@ -1,21 +0,0 @@ -[package] -authors.workspace = true -categories.workspace = true -description = "" -edition.workspace = true -homepage.workspace = true -keywords.workspace = true -license.workspace = true -name = "pgt_commands" -repository.workspace = true -version = "0.0.0" - - -[dependencies] -anyhow = "1.0.62" -async-std = "1.12.0" -pgt_text_size.workspace = true -sqlx.workspace = true - -[lib] -doctest = false diff --git a/crates/pgt_commands/src/command.rs b/crates/pgt_commands/src/command.rs deleted file mode 100644 index 9449efb6..00000000 --- a/crates/pgt_commands/src/command.rs +++ /dev/null @@ -1,32 +0,0 @@ -pub enum CommandType { - ExecuteStatement, -} - -impl CommandType { - pub const ALL: [CommandType; 1] = [CommandType::ExecuteStatement]; - - pub fn id(&self) -> &str { - match self { - CommandType::ExecuteStatement => "executeStatement", - } - } - - pub fn label(&self) -> &str { - match self { - CommandType::ExecuteStatement => "Execute Statement", - } - } - - pub fn from_id(s: &str) -> Option { - match s { - "executeStatement" => Some(CommandType::ExecuteStatement), - _ => None, - } - } -} - -pub trait Command { - type ExecuteStatement; - - fn command_type() -> CommandType; -} diff --git a/crates/pgt_commands/src/execute_statement.rs b/crates/pgt_commands/src/execute_statement.rs deleted file mode 100644 index 299f9d36..00000000 --- a/crates/pgt_commands/src/execute_statement.rs +++ /dev/null @@ -1,44 +0,0 @@ -use sqlx::{Executor, PgPool, postgres::PgQueryResult}; - -use crate::command::{Command, CommandType}; - -pub struct ExecuteStatementCommand { - statement: String, -} - -impl ExecuteStatementCommand { - pub fn new(statement: String) -> Self { - Self { statement } - } - - pub async fn run(&self, conn: Option) -> anyhow::Result { - match conn { - Some(conn) => match conn.execute(self.statement.as_str()).await { - Ok(res) => Ok(res), - Err(e) => Err(anyhow::anyhow!(e.to_string())), - }, - _ => Err(anyhow::anyhow!("No connection to database".to_string())), - } - } - - pub fn trim_statement(stmt: String, max_length: usize) -> String { - let len = stmt.len(); - if len <= max_length { - return stmt; - } - - let half = max_length / 2; - let start = &stmt[..half]; - let end = &stmt[len - half + (max_length % 2)..]; - - format!("{}...{}", start, end) - } -} - -impl Command for ExecuteStatementCommand { - type ExecuteStatement = ExecuteStatementCommand; - - fn command_type() -> CommandType { - CommandType::ExecuteStatement - } -} diff --git a/crates/pgt_commands/src/lib.rs b/crates/pgt_commands/src/lib.rs deleted file mode 100644 index 8a58fb11..00000000 --- a/crates/pgt_commands/src/lib.rs +++ /dev/null @@ -1,5 +0,0 @@ -pub mod command; -pub mod execute_statement; - -pub use command::*; -pub use execute_statement::*; diff --git a/crates/pgt_configuration/src/database.rs b/crates/pgt_configuration/src/database.rs index 6ec5773f..209f86dc 100644 --- a/crates/pgt_configuration/src/database.rs +++ b/crates/pgt_configuration/src/database.rs @@ -1,3 +1,4 @@ +use biome_deserialize::StringSet; use biome_deserialize_macros::{Merge, Partial}; use bpaf::Bpaf; use serde::{Deserialize, Serialize}; @@ -28,6 +29,9 @@ pub struct DatabaseConfiguration { #[partial(bpaf(long("database")))] pub database: String, + #[partial(bpaf(long("allow_statement_executions_against")))] + pub allow_statement_executions_against: StringSet, + /// The connection timeout in seconds. #[partial(bpaf(long("conn_timeout_secs"), fallback(Some(10)), debug_fallback))] pub conn_timeout_secs: u16, @@ -41,6 +45,7 @@ impl Default for DatabaseConfiguration { username: "postgres".to_string(), password: "postgres".to_string(), database: "postgres".to_string(), + allow_statement_executions_against: Default::default(), conn_timeout_secs: 10, } } diff --git a/crates/pgt_configuration/src/lib.rs b/crates/pgt_configuration/src/lib.rs index aaf5ac07..f262450d 100644 --- a/crates/pgt_configuration/src/lib.rs +++ b/crates/pgt_configuration/src/lib.rs @@ -111,6 +111,7 @@ impl PartialConfiguration { password: Some("postgres".to_string()), database: Some("postgres".to_string()), conn_timeout_secs: Some(10), + allow_statement_executions_against: Default::default(), }), } } diff --git a/crates/pgt_lsp/Cargo.toml b/crates/pgt_lsp/Cargo.toml index 56086da0..4fafc27f 100644 --- a/crates/pgt_lsp/Cargo.toml +++ b/crates/pgt_lsp/Cargo.toml @@ -28,6 +28,7 @@ pgt_workspace = { workspace = true } rustc-hash = { workspace = true } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } +strum = { workspace = true } tokio = { workspace = true, features = ["rt", "io-std"] } tower-lsp = { version = "0.20.0" } tracing = { workspace = true, features = ["attributes"] } diff --git a/crates/pgt_lsp/src/capabilities.rs b/crates/pgt_lsp/src/capabilities.rs index 8258811e..6bc81084 100644 --- a/crates/pgt_lsp/src/capabilities.rs +++ b/crates/pgt_lsp/src/capabilities.rs @@ -1,10 +1,15 @@ use pgt_lsp_converters::{PositionEncoding, WideEncoding, negotiated_encoding}; +use pgt_workspace::code_actions::{CommandActionCategory, CommandActionCategoryIter}; +use strum::{EnumIter, IntoEnumIterator}; use tower_lsp::lsp_types::{ - ClientCapabilities, CompletionOptions, PositionEncodingKind, SaveOptions, ServerCapabilities, - TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions, - TextDocumentSyncSaveOptions, WorkDoneProgressOptions, + ClientCapabilities, CodeActionOptions, CompletionOptions, ExecuteCommandOptions, + PositionEncodingKind, SaveOptions, ServerCapabilities, TextDocumentSyncCapability, + TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentSyncSaveOptions, + WorkDoneProgressOptions, }; +use crate::handlers::code_actions::command_id; + /// The capabilities to send from server as part of [`InitializeResult`] /// /// [`InitializeResult`]: lspower::lsp::InitializeResult @@ -46,10 +51,19 @@ pub(crate) fn server_capabilities(capabilities: &ClientCapabilities) -> ServerCa work_done_progress: None, }, }), + execute_command_provider: Some(ExecuteCommandOptions { + commands: CommandActionCategory::iter() + .map(|c| command_id(&c)) + .collect::>(), + + ..Default::default() + }), document_formatting_provider: None, document_range_formatting_provider: None, document_on_type_formatting_provider: None, - code_action_provider: None, + code_action_provider: Some(tower_lsp::lsp_types::CodeActionProviderCapability::Simple( + true, + )), rename_provider: None, ..Default::default() } diff --git a/crates/pgt_lsp/src/handlers.rs b/crates/pgt_lsp/src/handlers.rs index d6a8e28f..638a6d03 100644 --- a/crates/pgt_lsp/src/handlers.rs +++ b/crates/pgt_lsp/src/handlers.rs @@ -1,2 +1,4 @@ +pub(crate) mod code_actions; pub(crate) mod completions; +mod helper; pub(crate) mod text_document; diff --git a/crates/pgt_lsp/src/handlers/code_actions.rs b/crates/pgt_lsp/src/handlers/code_actions.rs new file mode 100644 index 00000000..140eb8a3 --- /dev/null +++ b/crates/pgt_lsp/src/handlers/code_actions.rs @@ -0,0 +1,114 @@ +use crate::session::Session; +use anyhow::{Result, anyhow}; +use tower_lsp::lsp_types::{ + self, CodeAction, CodeActionDisabled, CodeActionOrCommand, Command, ExecuteCommandParams, + MessageType, +}; + +use pgt_workspace::code_actions::{ + CodeActionKind, CodeActionsParams, CommandActionCategory, ExecuteStatementParams, +}; + +use super::helper; + +pub fn get_actions( + session: &Session, + params: lsp_types::CodeActionParams, +) -> Result { + let url = params.text_document.uri; + let path = session.file_path(&url)?; + + let cursor_position = helper::get_cursor_position(session, &url, params.range.start)?; + + let workspace_actions = session.workspace.pull_code_actions(CodeActionsParams { + path, + cursor_position, + only: vec![], + skip: vec![], + })?; + + let actions: Vec = workspace_actions + .actions + .into_iter() + .filter_map(|action| match action.kind { + CodeActionKind::Command(command) => { + let command_id: String = command_id(&command.category); + let title = action.title; + + match command.category { + CommandActionCategory::ExecuteStatement(stmt_id) => Some(CodeAction { + title: title.clone(), + kind: Some(lsp_types::CodeActionKind::EMPTY), + command: Some({ + Command { + title: title.clone(), + command: command_id, + arguments: Some(vec![ + serde_json::Value::Number(stmt_id.into()), + serde_json::to_value(&url).unwrap(), + ]), + } + }), + disabled: action + .disabled_reason + .map(|reason| CodeActionDisabled { reason }), + ..Default::default() + }), + } + } + + _ => todo!(), + }) + .collect(); + + Ok(actions + .into_iter() + .map(|ac| CodeActionOrCommand::CodeAction(ac)) + .collect()) +} + +pub fn command_id(command: &CommandActionCategory) -> String { + match command { + CommandActionCategory::ExecuteStatement(_) => "pgt.executeStatement".into(), + } +} + +pub async fn execute_command( + session: &Session, + params: ExecuteCommandParams, +) -> anyhow::Result> { + let command = params.command; + + match command.as_str() { + "pgt.executeStatement" => { + let id: usize = serde_json::from_value(params.arguments[0].clone())?; + let doc_url: lsp_types::Url = serde_json::from_value(params.arguments[1].clone())?; + + let path = session.file_path(&doc_url)?; + + let result = session + .workspace + .execute_statement(ExecuteStatementParams { + statement_id: id, + path, + })?; + + /** + * Updating all diagnostics: the changes caused by the statement execution + * might affect many files. + * + * TODO: in test.sql, this seems to work after create table, but not after drop table. + */ + session.update_all_diagnostics().await; + + session + .client + .show_message(MessageType::INFO, result.message) + .await; + + Ok(None) + } + + any => Err(anyhow!(format!("Unknown command: {}", any))), + } +} diff --git a/crates/pgt_lsp/src/handlers/completions.rs b/crates/pgt_lsp/src/handlers/completions.rs index 4eb0436a..2abb63bd 100644 --- a/crates/pgt_lsp/src/handlers/completions.rs +++ b/crates/pgt_lsp/src/handlers/completions.rs @@ -3,6 +3,8 @@ use anyhow::Result; use pgt_workspace::{WorkspaceError, workspace}; use tower_lsp::lsp_types::{self, CompletionItem, CompletionItemLabelDetails}; +use super::helper; + #[tracing::instrument(level = "trace", skip_all)] pub fn get_completions( session: &Session, @@ -11,27 +13,16 @@ pub fn get_completions( let url = params.text_document_position.text_document.uri; let path = session.file_path(&url)?; - let client_capabilities = session - .client_capabilities() - .expect("Client capabilities not established for current session."); - - let line_index = session - .document(&url) - .map(|doc| doc.line_index) - .map_err(|_| anyhow::anyhow!("Document not found."))?; - - let offset = pgt_lsp_converters::from_proto::offset( - &line_index, - params.text_document_position.position, - pgt_lsp_converters::negotiated_encoding(client_capabilities), - )?; - let completion_result = match session .workspace .get_completions(workspace::GetCompletionsParams { path, - position: offset, + position: helper::get_cursor_position( + session, + &url, + params.text_document_position.position, + )?, }) { Ok(result) => result, Err(e) => match e { diff --git a/crates/pgt_lsp/src/handlers/helper.rs b/crates/pgt_lsp/src/handlers/helper.rs new file mode 100644 index 00000000..99de22f1 --- /dev/null +++ b/crates/pgt_lsp/src/handlers/helper.rs @@ -0,0 +1,26 @@ +use crate::session::Session; +use pgt_text_size::TextSize; +use tower_lsp::lsp_types; + +pub fn get_cursor_position( + session: &Session, + url: &lsp_types::Url, + position: lsp_types::Position, +) -> anyhow::Result { + let client_capabilities = session + .client_capabilities() + .expect("Client capabilities not established for current session."); + + let line_index = session + .document(url) + .map(|doc| doc.line_index) + .map_err(|_| anyhow::anyhow!("Document not found."))?; + + let cursor_pos = pgt_lsp_converters::from_proto::offset( + &line_index, + position, + pgt_lsp_converters::negotiated_encoding(client_capabilities), + )?; + + Ok(cursor_pos) +} diff --git a/crates/pgt_lsp/src/server.rs b/crates/pgt_lsp/src/server.rs index 17d8cf5e..562a0777 100644 --- a/crates/pgt_lsp/src/server.rs +++ b/crates/pgt_lsp/src/server.rs @@ -252,6 +252,28 @@ impl LanguageServer for LSPServer { Err(e) => LspResult::Err(into_lsp_error(e)), } } + + #[tracing::instrument(level = "trace", skip(self))] + async fn code_action(&self, params: CodeActionParams) -> LspResult> { + match handlers::code_actions::get_actions(&self.session, params) { + Ok(result) => { + tracing::info!("Got Code Actions: {:?}", result); + return LspResult::Ok(Some(result)); + } + Err(e) => LspResult::Err(into_lsp_error(e)), + } + } + + #[tracing::instrument(level = "trace", skip(self))] + async fn execute_command( + &self, + params: ExecuteCommandParams, + ) -> LspResult> { + match handlers::code_actions::execute_command(&self.session, params).await { + Ok(result) => LspResult::Ok(None), + Err(err) => LspResult::Err(into_lsp_error(err)), + } + } } impl Drop for LSPServer { diff --git a/crates/pgt_lsp/tests/server.rs b/crates/pgt_lsp/tests/server.rs index b1edb406..fd5e15d0 100644 --- a/crates/pgt_lsp/tests/server.rs +++ b/crates/pgt_lsp/tests/server.rs @@ -17,6 +17,7 @@ use pgt_test_utils::test_database::get_new_test_db; use pgt_workspace::DynRef; use serde::Serialize; use serde::de::DeserializeOwned; +use serde_json::Value; use serde_json::{from_value, to_value}; use sqlx::Executor; use std::any::type_name; @@ -28,8 +29,13 @@ use tower_lsp::LspService; use tower_lsp::jsonrpc; use tower_lsp::jsonrpc::Response; use tower_lsp::lsp_types as lsp; +use tower_lsp::lsp_types::CodeActionContext; +use tower_lsp::lsp_types::CodeActionOrCommand; +use tower_lsp::lsp_types::CodeActionParams; +use tower_lsp::lsp_types::CodeActionResponse; use tower_lsp::lsp_types::CompletionParams; use tower_lsp::lsp_types::CompletionResponse; +use tower_lsp::lsp_types::ExecuteCommandParams; use tower_lsp::lsp_types::PartialResultParams; use tower_lsp::lsp_types::Position; use tower_lsp::lsp_types::Range; @@ -551,3 +557,143 @@ async fn test_completions() -> Result<()> { Ok(()) } + +#[tokio::test] +async fn test_execute_statement() -> Result<()> { + let factory = ServerFactory::default(); + let mut fs = MemoryFileSystem::default(); + let test_db = get_new_test_db().await; + + let database = test_db + .connect_options() + .get_database() + .unwrap() + .to_string(); + let host = test_db.connect_options().get_host().to_string(); + + let conf = PartialConfiguration { + db: Some(PartialDatabaseConfiguration { + database: Some(database), + host: Some(host), + ..Default::default() + }), + ..Default::default() + }; + + fs.insert( + url!("postgrestools.jsonc").to_file_path().unwrap(), + serde_json::to_string_pretty(&conf).unwrap(), + ); + + let (service, client) = factory + .create_with_fs(None, DynRef::Owned(Box::new(fs))) + .into_inner(); + + let (stream, sink) = client.split(); + let mut server = Server::new(service); + + let (sender, _) = channel(CHANNEL_BUFFER_SIZE); + let reader = tokio::spawn(client_handler(stream, sink, sender)); + + server.initialize().await?; + server.initialized().await?; + + server.load_configuration().await?; + + let users_tbl_exists = async || { + let result = sqlx::query!( + r#" + select exists ( + select 1 as exists + from pg_catalog.pg_tables + where tablename = 'users' + ); + "# + ) + .fetch_one(&test_db.clone()) + .await; + + result.unwrap().exists.unwrap() + }; + + assert_eq!( + users_tbl_exists().await, + false, + "The user table shouldn't exist at this point." + ); + + let doc_content = r#" + create table users ( + id serial primary key, + name text, + email text + ); + "#; + + let doc_url = url!("test.sql"); + + server + .open_named_document(doc_content.to_string(), doc_url.clone()) + .await?; + + let code_actions_response = server + .request::( + "textDocument/codeAction", + "_code_action", + CodeActionParams { + text_document: TextDocumentIdentifier { + uri: doc_url.clone(), + }, + range: Range { + start: Position::new(3, 7), + end: Position::new(3, 7), + }, // just somewhere within the statement. + context: CodeActionContext::default(), + partial_result_params: PartialResultParams::default(), + work_done_progress_params: WorkDoneProgressParams::default(), + }, + ) + .await? + .unwrap(); + + let exec_statement_command: (String, Vec) = code_actions_response + .iter() + .find_map(|action_or_cmd| match action_or_cmd { + lsp::CodeActionOrCommand::CodeAction(code_action) => { + let command = code_action.command.as_ref(); + if command.is_some_and(|cmd| &cmd.command == "pgt.executeStatement") { + let command = command.unwrap(); + let arguments = command.arguments.as_ref().unwrap().clone(); + Some((command.command.clone(), arguments)) + } else { + None + } + } + + _ => None, + }) + .expect("Did not find executeStatement command!"); + + server + .request::>( + "workspace/executeCommand", + "_execStmt", + ExecuteCommandParams { + command: exec_statement_command.0, + arguments: exec_statement_command.1, + ..Default::default() + }, + ) + .await?; + + assert_eq!( + users_tbl_exists().await, + true, + "Users table did not exists even though it should've been created by the workspace/executeStatement command." + ); + + server.shutdown().await?; + reader.abort(); + + Ok(()) +} diff --git a/crates/pgt_workspace/Cargo.toml b/crates/pgt_workspace/Cargo.toml index 33b0b231..7df42b19 100644 --- a/crates/pgt_workspace/Cargo.toml +++ b/crates/pgt_workspace/Cargo.toml @@ -12,9 +12,11 @@ version = "0.0.0" [dependencies] -biome_deserialize = "0.6.0" -dashmap = "5.5.3" -futures = "0.3.31" +biome_deserialize = "0.6.0" +dashmap = "5.5.3" +futures = "0.3.31" +globset = "0.4.16" + ignore = { workspace = true } pgt_analyse = { workspace = true, features = ["serde"] } pgt_analyser = { workspace = true } @@ -33,6 +35,7 @@ schemars = { workspace = true, optional = true } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true, features = ["raw_value"] } sqlx.workspace = true +strum = { workspace = true } tokio = { workspace = true, features = ["rt", "rt-multi-thread"] } tracing = { workspace = true, features = ["attributes", "log"] } tree-sitter.workspace = true diff --git a/crates/pgt_workspace/src/code_actions.rs b/crates/pgt_workspace/src/code_actions.rs new file mode 100644 index 00000000..5e3cd883 --- /dev/null +++ b/crates/pgt_workspace/src/code_actions.rs @@ -0,0 +1,65 @@ +use crate::workspace::StatementId; +use pgt_configuration::RuleSelector; +use pgt_fs::PgTPath; +use pgt_text_size::TextSize; + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub struct CodeActionsParams { + pub path: PgTPath, + pub cursor_position: TextSize, + pub only: Vec, + pub skip: Vec, +} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub struct CodeActionsResult { + pub actions: Vec, +} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub struct CodeAction { + pub title: String, + pub kind: CodeActionKind, + pub disabled_reason: Option, +} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub enum CodeActionKind { + Edit(EditAction), + Command(CommandAction), + EditAndCommand(EditAction, CommandAction), +} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub struct EditAction {} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub struct CommandAction { + pub category: CommandActionCategory, +} + +#[derive(Debug, serde::Serialize, serde::Deserialize, strum::EnumIter)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] + +pub enum CommandActionCategory { + ExecuteStatement(StatementId), +} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub struct ExecuteStatementParams { + pub statement_id: StatementId, + pub path: PgTPath, +} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] +pub struct ExecuteStatementResult { + pub message: String, +} diff --git a/crates/pgt_workspace/src/lib.rs b/crates/pgt_workspace/src/lib.rs index ae3004d7..a631853e 100644 --- a/crates/pgt_workspace/src/lib.rs +++ b/crates/pgt_workspace/src/lib.rs @@ -3,12 +3,14 @@ use std::ops::{Deref, DerefMut}; use pgt_console::Console; use pgt_fs::{FileSystem, OsFileSystem}; +pub mod code_actions; pub mod configuration; pub mod diagnostics; pub mod dome; pub mod matcher; pub mod settings; pub mod workspace; + #[cfg(feature = "schema")] pub mod workspace_types; diff --git a/crates/pgt_workspace/src/settings.rs b/crates/pgt_workspace/src/settings.rs index 2ae10c08..c635d167 100644 --- a/crates/pgt_workspace/src/settings.rs +++ b/crates/pgt_workspace/src/settings.rs @@ -1,4 +1,5 @@ use biome_deserialize::StringSet; +use globset::Glob; use pgt_diagnostics::Category; use std::{ borrow::Cow, @@ -273,6 +274,7 @@ pub struct DatabaseSettings { pub password: String, pub database: String, pub conn_timeout_secs: Duration, + pub allow_statement_executions: bool, } impl Default for DatabaseSettings { @@ -284,6 +286,7 @@ impl Default for DatabaseSettings { password: "postgres".to_string(), database: "postgres".to_string(), conn_timeout_secs: Duration::from_secs(10), + allow_statement_executions: true, } } } @@ -291,16 +294,36 @@ impl Default for DatabaseSettings { impl From for DatabaseSettings { fn from(value: PartialDatabaseConfiguration) -> Self { let d = DatabaseSettings::default(); + + let database = value.database.unwrap_or(d.database); + let host = value.host.unwrap_or(d.host); + + let allow_statement_executions = value + .allow_statement_executions_against + .map(|stringset| { + stringset.iter().any(|pattern| { + let glob = Glob::new(pattern) + .expect(format!("Invalid pattern: {}", pattern).as_str()) + .compile_matcher(); + + glob.is_match(format!("{}/{}", host, database)) + }) + }) + .unwrap_or(false); + Self { - host: value.host.unwrap_or(d.host), port: value.port.unwrap_or(d.port), username: value.username.unwrap_or(d.username), password: value.password.unwrap_or(d.password), - database: value.database.unwrap_or(d.database), + database, + host, + conn_timeout_secs: value .conn_timeout_secs .map(|s| Duration::from_secs(s.into())) .unwrap_or(d.conn_timeout_secs), + + allow_statement_executions, } } } @@ -415,3 +438,43 @@ impl PartialConfigurationExt for PartialConfiguration { Ok((None, vec![])) } } + +#[cfg(test)] +mod tests { + use biome_deserialize::StringSet; + use pgt_configuration::database::PartialDatabaseConfiguration; + + use super::DatabaseSettings; + + #[test] + fn should_identify_allowed_statement_executions() { + let partial_config = PartialDatabaseConfiguration { + allow_statement_executions_against: Some(StringSet::from_iter( + vec![String::from("localhost/*")].into_iter(), + )), + host: Some("localhost".into()), + database: Some("test-db".into()), + ..Default::default() + }; + + let config = DatabaseSettings::from(partial_config); + + assert_eq!(config.allow_statement_executions, true) + } + + #[test] + fn should_identify_not_allowed_statement_executions() { + let partial_config = PartialDatabaseConfiguration { + allow_statement_executions_against: Some(StringSet::from_iter( + vec![String::from("localhost/*")].into_iter(), + )), + host: Some("production".into()), + database: Some("test-db".into()), + ..Default::default() + }; + + let config = DatabaseSettings::from(partial_config); + + assert_eq!(config.allow_statement_executions, false) + } +} diff --git a/crates/pgt_workspace/src/workspace.rs b/crates/pgt_workspace/src/workspace.rs index 8b192bf7..13750b94 100644 --- a/crates/pgt_workspace/src/workspace.rs +++ b/crates/pgt_workspace/src/workspace.rs @@ -7,11 +7,18 @@ use pgt_fs::PgTPath; use pgt_text_size::{TextRange, TextSize}; use serde::{Deserialize, Serialize}; -use crate::WorkspaceError; +use crate::{ + WorkspaceError, + code_actions::{ + CodeActionsParams, CodeActionsResult, ExecuteStatementParams, ExecuteStatementResult, + }, +}; mod client; mod server; +pub(crate) use server::StatementId; + #[derive(Debug, serde::Serialize, serde::Deserialize)] #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))] pub struct OpenFileParams { @@ -115,6 +122,12 @@ pub trait Workspace: Send + Sync + RefUnwindSafe { params: PullDiagnosticsParams, ) -> Result; + /// Retrieves a list of available code_actions for a file/cursor_position + fn pull_code_actions( + &self, + params: CodeActionsParams, + ) -> Result; + fn get_completions( &self, params: GetCompletionsParams, @@ -145,6 +158,11 @@ pub trait Workspace: Send + Sync + RefUnwindSafe { /// /// If the file path matches, then `true` is returned, and it should be considered ignored. fn is_path_ignored(&self, params: IsPathIgnoredParams) -> Result; + + fn execute_statement( + &self, + params: ExecuteStatementParams, + ) -> Result; } /// Convenience function for constructing a server instance of [Workspace] diff --git a/crates/pgt_workspace/src/workspace/client.rs b/crates/pgt_workspace/src/workspace/client.rs index a6955c1e..beb97b7c 100644 --- a/crates/pgt_workspace/src/workspace/client.rs +++ b/crates/pgt_workspace/src/workspace/client.rs @@ -89,6 +89,20 @@ impl Workspace for WorkspaceClient where T: WorkspaceTransport + RefUnwindSafe + Send + Sync, { + fn pull_code_actions( + &self, + params: crate::code_actions::CodeActionsParams, + ) -> Result { + self.request("pgt/code_actions", params) + } + + fn execute_statement( + &self, + params: crate::code_actions::ExecuteStatementParams, + ) -> Result { + self.request("pgt/execute_statement", params) + } + fn open_file(&self, params: OpenFileParams) -> Result<(), WorkspaceError> { self.request("pgt/open_file", params) } diff --git a/crates/pgt_workspace/src/workspace/server.rs b/crates/pgt_workspace/src/workspace/server.rs index 942ae34d..39155e94 100644 --- a/crates/pgt_workspace/src/workspace/server.rs +++ b/crates/pgt_workspace/src/workspace/server.rs @@ -5,6 +5,7 @@ use async_helper::run_async; use change::StatementChange; use dashmap::DashMap; use db_connection::DbConnection; +pub(crate) use document::StatementId; use document::{Document, Statement}; use futures::{StreamExt, stream}; use pg_query::PgQueryStore; @@ -14,11 +15,16 @@ use pgt_diagnostics::{Diagnostic, DiagnosticExt, Severity, serde::Diagnostic as use pgt_fs::{ConfigName, PgTPath}; use pgt_typecheck::TypecheckParams; use schema_cache_manager::SchemaCacheManager; +use sqlx::Executor; use tracing::info; use tree_sitter::TreeSitterStore; use crate::{ WorkspaceError, + code_actions::{ + self, CodeAction, CodeActionKind, CodeActionsResult, CommandAction, CommandActionCategory, + ExecuteStatementResult, + }, configuration::to_analyser_rules, settings::{Settings, SettingsHandle, SettingsHandleMut}, workspace::PullDiagnosticsResult, @@ -253,6 +259,101 @@ impl Workspace for WorkspaceServer { Ok(self.is_ignored(params.pgt_path.as_path())) } + fn pull_code_actions( + &self, + params: code_actions::CodeActionsParams, + ) -> Result { + let doc = self + .documents + .get(¶ms.path) + .ok_or(WorkspaceError::not_found())?; + + let eligible_statements = doc + .iter_statements_with_text_and_range() + .filter(|(_, range, _)| range.contains(params.cursor_position)); + + let mut actions: Vec = vec![]; + + let settings = self + .settings + .read() + .expect("Unable to read settings for Code Actions"); + + let disabled_reason: Option = if settings.db.allow_statement_executions { + None + } else { + Some("Statement execution not allowed against database.".into()) + }; + + for (stmt, range, txt) in eligible_statements { + let title = format!( + "Execute Statement: {}...", + txt.chars().take(50).collect::() + ); + + actions.push(CodeAction { + title, + kind: CodeActionKind::Command(CommandAction { + category: CommandActionCategory::ExecuteStatement(stmt.id), + }), + disabled_reason: disabled_reason.clone(), + }); + } + + Ok(CodeActionsResult { actions }) + } + + fn execute_statement( + &self, + params: code_actions::ExecuteStatementParams, + ) -> Result { + let doc = self + .documents + .get(¶ms.path) + .ok_or(WorkspaceError::not_found())?; + + if self + .pg_query + .get_ast(&Statement { + path: params.path, + id: params.statement_id, + }) + .is_none() + { + return Ok(ExecuteStatementResult { + message: "Statement is invalid.".into(), + }); + }; + + let sql: String = match doc.get_txt(params.statement_id) { + Some(txt) => txt, + None => { + return Ok(ExecuteStatementResult { + message: "Statement was not found in document.".into(), + }); + } + }; + + let conn = self.connection.write().unwrap(); + let pool = match conn.get_pool() { + Some(p) => p, + None => { + return Ok(ExecuteStatementResult { + message: "Not connected to database.".into(), + }); + } + }; + + let result = run_async(async move { pool.execute(sqlx::query(&sql)).await })??; + + Ok(ExecuteStatementResult { + message: format!( + "Successfully executed statement. Rows affected: {}", + result.rows_affected() + ), + }) + } + fn pull_diagnostics( &self, params: super::PullDiagnosticsParams, diff --git a/crates/pgt_workspace/src/workspace/server/document.rs b/crates/pgt_workspace/src/workspace/server/document.rs index d77d9e97..9ef8c234 100644 --- a/crates/pgt_workspace/src/workspace/server/document.rs +++ b/crates/pgt_workspace/src/workspace/server/document.rs @@ -11,7 +11,7 @@ pub(crate) struct Statement { pub(crate) id: StatementId, } -pub type StatementId = usize; +pub(crate) type StatementId = usize; type StatementPos = (StatementId, TextRange); @@ -103,6 +103,16 @@ impl Document { ) }) } + + pub fn get_txt(&self, stmt_id: StatementId) -> Option { + self.positions + .iter() + .find(|pos| pos.0 == stmt_id) + .map(|(_, range)| { + let stmt = &self.content[range.start().into()..range.end().into()]; + stmt.to_owned() + }) + } } pub(crate) struct IdGenerator { diff --git a/crates/pgt_workspace/src/workspace/server/schema_cache_manager.rs b/crates/pgt_workspace/src/workspace/server/schema_cache_manager.rs index b17a96f8..57a37536 100644 --- a/crates/pgt_workspace/src/workspace/server/schema_cache_manager.rs +++ b/crates/pgt_workspace/src/workspace/server/schema_cache_manager.rs @@ -48,6 +48,7 @@ impl SchemaCacheManager { // return early if the connection string is the same let inner = self.inner.read().unwrap(); if new_conn_str == inner.conn_str { + tracing::info!("Same connection string, no updates."); return Ok(SchemaCacheHandle::wrap(inner)); } } @@ -63,6 +64,7 @@ impl SchemaCacheManager { if new_conn_str != inner.conn_str { inner.cache = refreshed; inner.conn_str = new_conn_str; + tracing::info!("Refreshed connection."); } } diff --git a/docs/index.md b/docs/index.md index f1477e17..b1de648c 100644 --- a/docs/index.md +++ b/docs/index.md @@ -14,7 +14,7 @@ A collection of language tools and a Language Server Protocol (LSP) implementati This project provides a toolchain for Postgres development -##### Postgres Language Server +##### Postgres Language Server  @@ -22,7 +22,7 @@ This project provides a toolchain for Postgres development  -The toolchain is built on Postgres' own parser `libpg_query` to ensure 100% syntax compatibility. It uses a Server-Client architecture and is a transport-agnostic. This means all features can be accessed through the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) as well as various interfaces like a CLI, HTTP APIs, or a WebAssembly module. +The toolchain is built on Postgres' own parser `libpg_query` to ensure 100% syntax compatibility. It uses a Server-Client architecture and is a transport-agnostic. This means all features can be accessed through the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) as well as various interfaces like a CLI, HTTP APIs, or a WebAssembly module. The following features are implemented: @@ -50,7 +50,7 @@ Now you can use Postgres Tools by simply running `./postgrestools`. ### NPM -If you are using Node, you can install the CLI via NPM. Run the following commands in a directory containing a `package.json` file. +If you are using Node, you can install the CLI via NPM. Run the following commands in a directory containing a `package.json` file. ```sh npm add --save-dev --save-exact @postgrestools/postgrestools @@ -78,7 +78,7 @@ postgrestools init You’ll now have a `postgrestools.jsonc` file in your directory: -[//]: # (BEGIN DEFAULT_CONFIGURATION) +[//]: # "BEGIN DEFAULT_CONFIGURATION" ```json { @@ -103,12 +103,13 @@ You’ll now have a `postgrestools.jsonc` file in your directory: "username": "postgres", "password": "postgres", "database": "postgres", - "connTimeoutSecs": 10 + "connTimeoutSecs": 10, + "allowStatementExecutionsAgainst": ["127.0.0.1/*", "localhost/*"] } } ``` -[//]: # (END DEFAULT_CONFIGURATION) +[//]: # "END DEFAULT_CONFIGURATION" Make sure to edit the database connection settings to connect to your local development database. To see all options, run `postgrestools --help`. @@ -129,9 +130,10 @@ Make sure to check out the other options by running `postgrestools --help`. We w #### Using the LSP Proxy Postgres Tools has a command called `lsp-proxy`. When executed, two processes will spawn: + - a daemon that does execute the requested operations; - a server that functions as a proxy between the requests of the client - the editor - and the server - the daemon; -If your editor is able to interact with a server and send [JSON-RPC](https://www.jsonrpc.org) requests, you only need to configure the editor to run that command. + If your editor is able to interact with a server and send [JSON-RPC](https://www.jsonrpc.org) requests, you only need to configure the editor to run that command. #### Using the daemon with the binary @@ -159,4 +161,3 @@ The daemon saves logs in your file system. Logs are stored in a folder called `p For other operative systems, you can find the folder in the system’s temporary directory. You can change the location of the `pgt-logs` folder via the `PGT_LOG_PATH` variable. - diff --git a/docs/schemas/0.0.0/schema.json b/docs/schemas/0.0.0/schema.json index 2f57a63d..086adf3d 100644 --- a/docs/schemas/0.0.0/schema.json +++ b/docs/schemas/0.0.0/schema.json @@ -73,6 +73,16 @@ "description": "The configuration of the database connection.", "type": "object", "properties": { + "allowStatementExecutionsAgainst": { + "anyOf": [ + { + "$ref": "#/definitions/StringSet" + }, + { + "type": "null" + } + ] + }, "connTimeoutSecs": { "description": "The connection timeout in seconds.", "type": [ diff --git a/docs/schemas/latest/schema.json b/docs/schemas/latest/schema.json index 2f57a63d..086adf3d 100644 --- a/docs/schemas/latest/schema.json +++ b/docs/schemas/latest/schema.json @@ -73,6 +73,16 @@ "description": "The configuration of the database connection.", "type": "object", "properties": { + "allowStatementExecutionsAgainst": { + "anyOf": [ + { + "$ref": "#/definitions/StringSet" + }, + { + "type": "null" + } + ] + }, "connTimeoutSecs": { "description": "The connection timeout in seconds.", "type": [ diff --git a/packages/@postgrestools/backend-jsonrpc/src/workspace.ts b/packages/@postgrestools/backend-jsonrpc/src/workspace.ts index 4aea83ce..5c9a1ac4 100644 --- a/packages/@postgrestools/backend-jsonrpc/src/workspace.ts +++ b/packages/@postgrestools/backend-jsonrpc/src/workspace.ts @@ -230,6 +230,7 @@ export interface PartialConfiguration { * The configuration of the database connection. */ export interface PartialDatabaseConfiguration { + allowStatementExecutionsAgainst?: StringSet; /** * The connection timeout in seconds. */ diff --git a/postgrestools.jsonc b/postgrestools.jsonc index ee9eccc1..325c7861 100644 --- a/postgrestools.jsonc +++ b/postgrestools.jsonc @@ -1,26 +1,27 @@ { - "$schema": "./docs/schemas/latest/schema.json", - "vcs": { - "enabled": false, - "clientKind": "git", - "useIgnoreFile": false - }, - "files": { - "ignore": [] - }, - "linter": { - "enabled": true, - "rules": { - "recommended": true - } - }, - // YOU CAN COMMENT ME OUT :) - "db": { - "host": "127.0.0.1", - "port": 5432, - "username": "postgres", - "password": "postgres", - "database": "postgres", - "connTimeoutSecs": 10 - } + "$schema": "./docs/schemas/latest/schema.json", + "vcs": { + "enabled": false, + "clientKind": "git", + "useIgnoreFile": false + }, + "files": { + "ignore": [] + }, + "linter": { + "enabled": true, + "rules": { + "recommended": true + } + }, + // YOU CAN COMMENT ME OUT :) + "db": { + "host": "127.0.0.1", + "port": 5432, + "username": "postgres", + "password": "postgres", + "database": "postgres", + "connTimeoutSecs": 10, + "allowStatementExecutionsAgainst": ["127.0.0.1/*", "localhost/*"] + } } diff --git a/test.sql b/test.sql index ea357c14..6da76762 100644 --- a/test.sql +++ b/test.sql @@ -1,11 +1,9 @@ -select id, name, test1231234123, unknown from co; +create table + unknown_users (id serial primary key, address text, email text); -select 14433313331333333333 +drop table unknown_users; -select * from test; - -alter tqjable test drop column id; - -alter table test drop column id; - -select lower(); +select + * +from + unknown_users; \ No newline at end of file