Merge branch 'main' into test/analyser-suite

Author: juleswritescode

.cursorignore

@@ -0,0 +1,3 @@
+# Add directories or file patterns to ignore during indexing (e.g. foo/ or *.csv)
+libpg_query/
+lib/tree_sitter_sql/tree-sitter-sql/

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: Release PG_CLI
+name: Release Binary
 
 on:
   workflow_dispatch:
@@ -61,28 +61,28 @@ jobs:
           DATABASE_URL: postgres://postgres:postgres@localhost:5432/postgres
 
       - name: 🛠️ Run Build
-        run: cargo build -p pg_cli --release --target ${{ matrix.config.target }}
+        run: cargo build -p pglt_cli --release --target ${{ matrix.config.target }}
 
       # windows is a special snowflake to, it saves binaries as .exe
       - name: 👦 Name the Binary
         if: matrix.config.os == 'windows-latest'
         run: |
           mkdir dist
-          cp target/${{ matrix.config.target }}/release/pg_cli.exe ./dist/pgcli_${{ matrix.config.target }}
+          cp target/${{ matrix.config.target }}/release/pglt.exe ./dist/pglt_${{ matrix.config.target }}
       - name: 👦 Name the Binary
         if: matrix.config.os != 'windows-latest'
         run: |
           mkdir dist
-          cp target/${{ matrix.config.target }}/release/pg_cli ./dist/pgcli_${{ matrix.config.target }}
+          cp target/${{ matrix.config.target }}/release/pglt ./dist/pglt_${{ matrix.config.target }}
 
       # It is not possible to return the artifacts from the matrix jobs individually: Matrix outputs overwrite each other.
       # A common workaround is to upload and download the resulting artifacts.
       - name: 👆 Upload Artifacts
         id: upload-artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: pgcli_${{ matrix.config.target }}
-          path: ./dist/pgcli_*
+          name: pglt_${{ matrix.config.target }}
+          path: ./dist/pglt_*
           # The default compression level is 6; this took the binary down from 350 to 330MB.
           # It is recommended to use a lower level for binaries, since the compressed result is not much smaller,
           # and the higher levels of compression take much longer.
@@ -113,7 +113,7 @@ jobs:
         id: download
         with:
           merge-multiple: true
-          pattern: pgcli_*
+          pattern: pglt_*
 
       - name: 📂 Create Release
         uses: softprops/action-gh-release@v2
@@ -124,7 +124,7 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           body: ${{ steps.create_changelog.outputs.content }}
           tag_name: ${{ steps.create_changelog.outputs.version }}
-          files: pgcli_*
+          files: pglt_*
           fail_on_unmatched_files: true
           draft: true
 

Cargo.lock

@@ -2,105 +2,29 @@
 
 # Postgres Language Server
 
-A Language Server for Postgres. Not SQL with flavors, just Postgres.
+A collection of language tools and a Language Server Protocol (LSP) implementation for Postgres, focusing on developer experience and reliable SQL tooling.
 
-> [!WARNING]
-> This is in active development and is only ready for collaborators. But we are getting there! You can find the current roadmap and opportunities to contribute in https://github.com/supabase-community/postgres_lsp/issues/136.
+## Overview
 
-## Features
+This project provides a toolchain for Postgres development, built on Postgres' own parser `libpg_query` to ensure 100% syntax compatibility. It is built on a Server-Client architecture with a transport-agnostic design. This means all features can be accessed not only through the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/), but also through other interfaces like a CLI, HTTP APIs, or a WebAssembly module. The goal is to make all the great Postgres tooling out there as accessible as possible, and to build anything that is missing ourselves.
 
-The [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) is an open protocol between code editors and servers to provide code intelligence tools such as code completion and syntax highlighting. This project implements such a language server for Postgres, significantly enhancing the developer experience within your favorite editor by adding:
+Currently, the following features are implemented:
+- Autocompletion
+- Syntax Error Highlighting
+- Type-checking (via `EXPLAIN` error insights)
+- Linter, inspired by [Squawk](https://squawkhq.com)
 
-- Lint
-- Hover
-- Typechecking
-- Syntax Error Diagnostics
-- Inlay Hints
-- Auto-Completion
-- Code actions such as `Execute the statement under the cursor`, or `Execute the current file`
-- Formatter
-- ... and many more
-
-We plan to support all of the above for SQL and PL/pgSQL function bodies too!
-
-## Motivation
-
-Despite the rising popularity of Postgres, support for the PL/pgSQL in IDEs and editors is limited. While there are some _generic_ SQL Language Servers[^1] offering the Postgres syntax as a "flavor" within the parser, they usually fall short due to the ever-evolving and complex syntax of PostgreSQL. There are a few proprietary IDEs[^2] that work well, but the features are only available within the respective IDE.
-
-This Language Server is designed to support Postgres, and only Postgres. The server uses [libpg_query](https://github.com/pganalyze/libpg_query), both as a git submodule for access to its protobuf file and as the [pg_query](https://crates.io/crates/pg_query/5.0.0) rust crate, therefore leveraging the PostgreSQL source to parse the SQL code reliably. Using Postgres within a Language Server might seem unconventional, but it's the only reliable way of parsing all valid PostgreSQL queries. You can find a longer rationale on why This is the Way™ [here](https://pganalyze.com/blog/parse-postgresql-queries-in-ruby). While libpg_query was built to execute SQL, and not to build a language server, any shortcomings have been successfully mitigated in the `parser` crate. You can read the [commented source code](./crates/parser/src/lib.rs) for more details on the inner workings of the parser.
-
-Once the parser is stable, and a robust and scalable data model is implemented, the language server will not only provide basic features such as semantic highlighting, code completion and syntax error diagnostics, but also serve as the user interface for all the great tooling of the Postgres ecosystem.
-
-## Installation
-
-> [!WARNING]
-> This is not ready for production use. Only install this if you want to help with development.
-
-> [!NOTE]
-> Interested in setting up a release process and client extensions for Neovim and VS Code? Please check out https://github.com/supabase-community/postgres_lsp/issues/136!
-
-### Neovim
-
-Add the postgres_lsp executable to your path, and add the following to your config to use it.
-
-```lua
-local util = require 'lspconfig.util'
-local lspconfig = require 'lspconfig'
-
-require('lspconfig.configs').postgres_lsp = {
-  default_config = {
-    name = 'postgres_lsp',
-    cmd = { 'postgres_lsp' },
-    filetypes = { 'sql' },
-    single_file_support = true,
-    root_dir = util.root_pattern 'root-file.txt',
-  },
-}
-
-lspconfig.postgres_lsp.setup { force_setup = true }
-```
-
-### Building from source
-
-You'll need _nightly_ Cargo, Node, and npm installed.
-
-Install the `libpg_query` submodule by running:
-
-```sh
-git submodule update --init --recursive
-```
-
-If you are using VS Code, you can install both the server and the client extension by running:
-
-```sh
-cargo xtask install
-```
-
-If you're not using VS Code, you can install the server by running:
-
-```sh
-cargo xtask install --server
-```
-
-The server binary will be installed in `.cargo/bin`. Make sure that `.cargo/bin` is in `$PATH`.
-
-### Github CodeSpaces
-
-You can setup your development environment on [CodeSpaces](https://github.com/features/codespaces).
-
-After your codespace boots up, run the following command in the shell to install Rust:
-
-```shell
-curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
-```
-
-Proceed with the rest of the installation as usual.
+Our current focus is on refining and enhancing these core features while building a robust and easily accessible infrastructure. For future plans and opportunities to contribute, please check out the issues and discussions. Any contributions are welcome!
 
 ## Contributors
 
-- [psteinroe](https://github.com/psteinroe) (Maintainer)
+- [psteinroe](https://github.com/psteinroe)
+- [juleswritescode](https://github.com/juleswritescode)
+
+## Acknowledgements
 
-## Footnotes
+A big thanks to the following projects, without which this project wouldn't have been possible:
 
-[^1]: Generic SQL Solutions: [sql-language-server](https://github.com/joe-re/sql-language-server), [pgFormatter](https://github.com/darold/pgFormatter/tree/master), [sql-parser-cst](https://github.com/nene/sql-parser-cst)
-[^2]: Proprietary IDEs: [DataGrip](https://www.jetbrains.com/datagrip/)
+- [libpg_query](https://github.com/pganalyze/libpg_query): For extracting the Postgres' parser
+- [Biome](https://github.com/biomejs/biome): For implementing a toolchain infrastructure we could copy from
+- [Squawk](https://github.com/sbdchd/squawk): For the linter inspiration

README.md

@@ -74,38 +74,34 @@ impl ActionCategory {
         match self {
             ActionCategory::QuickFix(tag) => {
                 if tag.is_empty() {
-                    Cow::Borrowed("quickfix.pglsp")
+                    Cow::Borrowed("quickfix.pglt")
                 } else {
-                    Cow::Owned(format!("quickfix.pglsp.{tag}"))
+                    Cow::Owned(format!("quickfix.pglt.{tag}"))
                 }
             }
 
-            ActionCategory::Refactor(RefactorKind::None) => Cow::Borrowed("refactor.pglsp"),
+            ActionCategory::Refactor(RefactorKind::None) => Cow::Borrowed("refactor.pglt"),
             ActionCategory::Refactor(RefactorKind::Extract) => {
-                Cow::Borrowed("refactor.extract.pglsp")
-            }
-            ActionCategory::Refactor(RefactorKind::Inline) => {
-                Cow::Borrowed("refactor.inline.pglsp")
+                Cow::Borrowed("refactor.extract.pglt")
             }
+            ActionCategory::Refactor(RefactorKind::Inline) => Cow::Borrowed("refactor.inline.pglt"),
             ActionCategory::Refactor(RefactorKind::Rewrite) => {
-                Cow::Borrowed("refactor.rewrite.pglsp")
+                Cow::Borrowed("refactor.rewrite.pglt")
             }
             ActionCategory::Refactor(RefactorKind::Other(tag)) => {
-                Cow::Owned(format!("refactor.{tag}.pglsp"))
+                Cow::Owned(format!("refactor.{tag}.pglt"))
             }
 
-            ActionCategory::Source(SourceActionKind::None) => Cow::Borrowed("source.pglsp"),
-            ActionCategory::Source(SourceActionKind::FixAll) => {
-                Cow::Borrowed("source.fixAll.pglsp")
-            }
+            ActionCategory::Source(SourceActionKind::None) => Cow::Borrowed("source.pglt"),
+            ActionCategory::Source(SourceActionKind::FixAll) => Cow::Borrowed("source.fixAll.pglt"),
             ActionCategory::Source(SourceActionKind::OrganizeImports) => {
-                Cow::Borrowed("source.organizeImports.pglsp")
+                Cow::Borrowed("source.organizeImports.pglt")
             }
             ActionCategory::Source(SourceActionKind::Other(tag)) => {
-                Cow::Owned(format!("source.{tag}.pglsp"))
+                Cow::Owned(format!("source.{tag}.pglt"))
             }
 
-            ActionCategory::Other(tag) => Cow::Owned(format!("{tag}.pglsp")),
+            ActionCategory::Other(tag) => Cow::Owned(format!("{tag}.pglt")),
         }
     }
 }

crates/pglt_analyse/src/categories.rs

@@ -45,7 +45,7 @@ impl AnalyserRules {
 /// A set of information useful to the analyser infrastructure
 #[derive(Debug, Default)]
 pub struct AnalyserOptions {
-    /// A data structured derived from the [`pglsp.toml`] file
+    /// A data structured derived from the [`pglt.toml`] file
     pub rules: AnalyserRules,
 }
 

crates/pglt_analyse/src/options.rs

@@ -79,7 +79,7 @@ Let's assume that the rule we implement support the following options:
 - `threshold`: an integer between 0 and 255;
 - `behaviorExceptions`: an array of strings.
 
-We would like to set the options in the `pglsp.toml` configuration file:
+We would like to set the options in the `pglt.toml` configuration file:
 
 ```toml
 [linter.rules.safety.myRule]
@@ -132,9 +132,9 @@ We currently require implementing _serde_'s traits `Deserialize`/`Serialize`.
 
 Also, we use other `serde` macros to adjust the JSON configuration:
 
-- `rename_all = "snake_case"`: it renames all fields in camel-case, so they are in line with the naming style of the `pglsp.toml`.
+- `rename_all = "snake_case"`: it renames all fields in camel-case, so they are in line with the naming style of the `pglt.toml`.
 - `deny_unknown_fields`: it raises an error if the configuration contains extraneous fields.
-- `default`: it uses the `Default` value when the field is missing from `pglsp.toml`. This macro makes the field optional.
+- `default`: it uses the `Default` value when the field is missing from `pglt.toml`. This macro makes the field optional.
 
 You can simply use a derive macros:
 

crates/pglt_analyser/CONTRIBUTING.md

@@ -16,3 +16,7 @@ pglt_analyse   = { workspace = true }
 pglt_console   = { workspace = true }
 pglt_query_ext = { workspace = true }
 serde          = { workspace = true }
+
+[dev-dependencies]
+pglt_diagnostics = { workspace = true }
+termcolor        = { workspace = true }

crates/pglt_analyser/Cargo.toml

@@ -12,7 +12,7 @@ declare_lint_rule! {
     ///
     /// ### Invalid
     ///
-    /// ```sql,ignore
+    /// ```sql,expect_diagnostic
     /// alter table test drop column id;
     /// ```
     ///

crates/pglt_analyser/src/lint/safety/ban_drop_column.rs

@@ -12,7 +12,7 @@ declare_lint_rule! {
     ///
     /// ### Invalid
     ///
-    /// ```sql,ignore
+    /// ```sql,expect_diagnostic
     /// alter table users alter column email drop not null;
     /// ```
     pub BanDropNotNull {