feat: add dblint with splinter (#631)

as simple as it gets for now.

will wire up pglinter next and then check if we can refactor linters to
share even more

fixed the generated documentation too, which makes up for most of the
changes.

Author: psteinroe

Cargo.lock

@@ -52,8 +52,10 @@ mimalloc = "0.1.43"
 tikv-jemallocator = "0.6.0"
 
 [dev-dependencies]
-assert_cmd = "2.0.16"
-insta      = { workspace = true, features = ["yaml"] }
+assert_cmd      = "2.0.16"
+insta           = { workspace = true, features = ["yaml"] }
+pgls_test_utils = { workspace = true }
+sqlx            = { workspace = true }
 
 [lib]
 doctest = false

crates/pgls_cli/Cargo.toml

@@ -3,6 +3,7 @@ use std::time::Instant;
 use crate::cli_options::CliOptions;
 use crate::reporter::Report;
 use crate::{CliDiagnostic, CliSession, VcsIntegration};
+use pgls_analyse::RuleCategoriesBuilder;
 use pgls_configuration::PartialConfiguration;
 use pgls_diagnostics::Error;
 use pgls_workspace::features::diagnostics::{PullDatabaseDiagnosticsParams, PullDiagnosticsResult};
@@ -24,10 +25,17 @@ pub fn dblint(
 
     let start = Instant::now();
 
+    let params = PullDatabaseDiagnosticsParams {
+        categories: RuleCategoriesBuilder::default().all().build(),
+        max_diagnostics,
+        only: Vec::new(), // Uses configuration settings
+        skip: Vec::new(), // Uses configuration settings
+    };
+
     let PullDiagnosticsResult {
         diagnostics,
         skipped_diagnostics,
-    } = workspace.pull_db_diagnostics(PullDatabaseDiagnosticsParams { max_diagnostics })?;
+    } = workspace.pull_db_diagnostics(params)?;
 
     let report = Report::new(
         diagnostics.into_iter().map(Error::from).collect(),

crates/pgls_cli/src/commands/dblint.rs

@@ -24,7 +24,7 @@ pub enum PgLSCommand {
     #[bpaf(command)]
     Version(#[bpaf(external(cli_options), hide_usage)] CliOptions),
 
-    /// Runs everything to the requested files.
+    /// Lints your database schema.
     #[bpaf(command)]
     Dblint {
         #[bpaf(external(partial_configuration), hide_usage, optional)]

crates/pgls_cli/src/commands/mod.rs

@@ -0,0 +1,117 @@
+use assert_cmd::Command;
+use insta::assert_snapshot;
+use sqlx::PgPool;
+use std::process::ExitStatus;
+
+const BIN: &str = "postgres-language-server";
+
+/// Get database URL from the pool's connect options
+/// Uses the known docker-compose credentials (postgres:postgres)
+fn get_database_url(pool: &PgPool) -> String {
+    let opts = pool.connect_options();
+    format!(
+        "postgres://postgres:postgres@{}:{}/{}",
+        opts.get_host(),
+        opts.get_port(),
+        opts.get_database().unwrap_or("postgres")
+    )
+}
+
+#[sqlx::test(migrator = "pgls_test_utils::MIGRATIONS")]
+#[cfg_attr(
+    target_os = "windows",
+    ignore = "snapshot expectations only validated on unix-like platforms"
+)]
+async fn dblint_empty_database_snapshot(test_db: PgPool) {
+    let url = get_database_url(&test_db);
+    let output = run_dblint(&url, &[]);
+    assert_snapshot!(output);
+}
+
+#[sqlx::test(migrator = "pgls_test_utils::MIGRATIONS")]
+#[cfg_attr(
+    target_os = "windows",
+    ignore = "snapshot expectations only validated on unix-like platforms"
+)]
+async fn dblint_detects_issues_snapshot(test_db: PgPool) {
+    // Setup: create table without primary key (triggers noPrimaryKey rule)
+    sqlx::raw_sql("CREATE TABLE test_no_pk (id int, name text)")
+        .execute(&test_db)
+        .await
+        .expect("Failed to create test table");
+
+    let url = get_database_url(&test_db);
+    let output = run_dblint(&url, &[]);
+    assert_snapshot!(output);
+}
+
+#[test]
+#[cfg_attr(
+    target_os = "windows",
+    ignore = "snapshot expectations only validated on unix-like platforms"
+)]
+fn dblint_no_database_snapshot() {
+    // Test that dblint completes gracefully when no database is configured
+    let mut cmd = Command::cargo_bin(BIN).expect("binary not built");
+    let output = cmd
+        .args(["dblint", "--disable-db", "--log-level", "none"])
+        .output()
+        .expect("failed to run CLI");
+
+    let normalized = normalize_output(
+        output.status,
+        &String::from_utf8_lossy(&output.stdout),
+        &String::from_utf8_lossy(&output.stderr),
+    );
+    assert_snapshot!(normalized);
+}
+
+fn run_dblint(url: &str, args: &[&str]) -> String {
+    let mut cmd = Command::cargo_bin(BIN).expect("binary not built");
+    let mut full_args = vec!["dblint", "--connection-string", url, "--log-level", "none"];
+    full_args.extend_from_slice(args);
+
+    let output = cmd.args(full_args).output().expect("failed to run CLI");
+
+    normalize_output(
+        output.status,
+        &String::from_utf8_lossy(&output.stdout),
+        &String::from_utf8_lossy(&output.stderr),
+    )
+}
+
+fn normalize_output(status: ExitStatus, stdout: &str, stderr: &str) -> String {
+    let normalized_stdout = normalize_durations(stdout);
+    let status_label = if status.success() {
+        "success"
+    } else {
+        "failure"
+    };
+    format!(
+        "status: {status_label}\nstdout:\n{}\nstderr:\n{}\n",
+        normalized_stdout.trim_end(),
+        stderr.trim_end()
+    )
+}
+
+fn normalize_durations(input: &str) -> String {
+    let mut content = input.to_owned();
+
+    let mut search_start = 0;
+    while let Some(relative) = content[search_start..].find(" in ") {
+        let start = search_start + relative + 4;
+        if let Some(end_rel) = content[start..].find('.') {
+            let end = start + end_rel;
+            if content[start..end].chars().any(|c| c.is_ascii_digit()) {
+                content.replace_range(start..end, "<duration>");
+                search_start = start + "<duration>".len() + 1;
+                continue;
+            }
+            search_start = end + 1;
+        } else {
+            break;
+        }
+    }
+
+    content
+}

crates/pgls_cli/tests/assert_dblint.rs

@@ -0,0 +1,20 @@
+---
+source: crates/pgls_cli/tests/assert_dblint.rs
+expression: output
+snapshot_kind: text
+---
+status: success
+stdout:
+Warning: Deprecated config filename detected. Use 'postgres-language-server.jsonc'.
+
+Command completed in <duration>.
+stderr:
+splinter/performance/noPrimaryKey ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Table \`public.test_no_pk\` does not have a primary key
+  
+  Detects if a table does not have a primary key. Tables without a primary key can be inefficient to interact with at scale.
+  
+  i table: public.test_no_pk
+  
+  i Remediation: https://supabase.com/docs/guides/database/database-linter?lint=0004_no_primary_key

crates/pgls_cli/tests/snapshots/assert_dblint__dblint_detects_issues_snapshot.snap

@@ -0,0 +1,11 @@
+---
+source: crates/pgls_cli/tests/assert_dblint.rs
+expression: output
+snapshot_kind: text
+---
+status: success
+stdout:
+Warning: Deprecated config filename detected. Use 'postgres-language-server.jsonc'.
+
+Command completed in <duration>.
+stderr:

crates/pgls_cli/tests/snapshots/assert_dblint__dblint_empty_database_snapshot.snap

@@ -0,0 +1,11 @@
+---
+source: crates/pgls_cli/tests/assert_dblint.rs
+expression: normalized
+snapshot_kind: text
+---
+status: success
+stdout:
+Warning: Deprecated config filename detected. Use 'postgres-language-server.jsonc'.
+
+Command completed in <duration>.
+stderr:

crates/pgls_cli/tests/snapshots/assert_dblint__dblint_no_database_snapshot.snap

@@ -42,6 +42,9 @@ pub use rules::{
     RuleWithFixOptions, RuleWithOptions,
 };
 use serde::{Deserialize, Serialize};
+use splinter::{
+    PartialSplinterConfiguration, SplinterConfiguration, partial_splinter_configuration,
+};
 pub use typecheck::{
     PartialTypecheckConfiguration, TypecheckConfiguration, partial_typecheck_configuration,
 };
@@ -86,6 +89,10 @@ pub struct Configuration {
     #[partial(type, bpaf(external(partial_linter_configuration), optional))]
     pub linter: LinterConfiguration,
 
+    /// The configuration for splinter
+    #[partial(type, bpaf(external(partial_splinter_configuration), optional))]
+    pub splinter: SplinterConfiguration,
+
     /// The configuration for type checking
     #[partial(type, bpaf(external(partial_typecheck_configuration), optional))]
     pub typecheck: TypecheckConfiguration,
@@ -127,6 +134,10 @@ impl PartialConfiguration {
                 }),
                 ..Default::default()
             }),
+            splinter: Some(PartialSplinterConfiguration {
+                enabled: Some(true),
+                ..Default::default()
+            }),
             typecheck: Some(PartialTypecheckConfiguration {
                 ..Default::default()
             }),

crates/pgls_configuration/src/lib.rs

@@ -46,6 +46,7 @@ impl std::str::FromStr for RuleGroup {
 }
 #[derive(Clone, Debug, Default, Deserialize, Eq, Merge, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(JsonSchema))]
+#[cfg_attr(feature = "schema", schemars(rename = "LinterRules"))]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct Rules {
     #[doc = r" It enables the lint rules recommended by Postgres Language Server. `true` by default."]