feat: support standard Postgres env vars for db connection

Support DATABASE_URL, PGHOST, PGPORT, PGUSER, PGPASSWORD, PGDATABASE
environment variables for configuring the database connection. Env vars
take highest priority, overriding CLI args, LSP settings, and config file
values.

Closes #302

Author: psteinroe

crates/pgls_configuration/src/database.rs

@@ -11,29 +11,29 @@ use serde::{Deserialize, Serialize};
 pub struct DatabaseConfiguration {
     /// A connection string that encodes the full connection setup.
     /// When provided, it takes precedence over the individual fields.
-    #[partial(bpaf(long("connection-string")))]
+    #[partial(bpaf(env("DATABASE_URL"), long("connection-string")))]
     pub connection_string: Option<String>,
 
     /// The host of the database.
     /// Required if you want database-related features.
     /// All else falls back to sensible defaults.
-    #[partial(bpaf(long("host")))]
+    #[partial(bpaf(env("PGHOST"), long("host")))]
     pub host: String,
 
     /// The port of the database.
-    #[partial(bpaf(long("port")))]
+    #[partial(bpaf(env("PGPORT"), long("port")))]
     pub port: u16,
 
     /// The username to connect to the database.
-    #[partial(bpaf(long("username")))]
+    #[partial(bpaf(env("PGUSER"), long("username")))]
     pub username: String,
 
     /// The password to connect to the database.
-    #[partial(bpaf(long("password")))]
+    #[partial(bpaf(env("PGPASSWORD"), long("password")))]
     pub password: String,
 
     /// The name of the database.
-    #[partial(bpaf(long("database")))]
+    #[partial(bpaf(env("PGDATABASE"), long("database")))]
     pub database: String,
 
     #[partial(bpaf(long("allow_statement_executions_against")))]
@@ -64,3 +64,156 @@ impl Default for DatabaseConfiguration {
         }
     }
 }
+
+impl PartialDatabaseConfiguration {
+    /// Creates a partial configuration from standard Postgres environment variables.
+    ///
+    /// Reads `DATABASE_URL`, `PGHOST`, `PGPORT`, `PGUSER`, `PGPASSWORD`, and `PGDATABASE`.
+    /// Returns `None` if no relevant env vars are set.
+    pub fn from_env() -> Option<Self> {
+        let database_url = std::env::var("DATABASE_URL").ok();
+        let pghost = std::env::var("PGHOST").ok();
+        let pgport = std::env::var("PGPORT")
+            .ok()
+            .and_then(|p| p.parse().ok());
+        let pguser = std::env::var("PGUSER").ok();
+        let pgpassword = std::env::var("PGPASSWORD").ok();
+        let pgdatabase = std::env::var("PGDATABASE").ok();
+
+        let has_any = database_url.is_some()
+            || pghost.is_some()
+            || pgport.is_some()
+            || pguser.is_some()
+            || pgpassword.is_some()
+            || pgdatabase.is_some();
+
+        if !has_any {
+            return None;
+        }
+
+        Some(Self {
+            connection_string: database_url,
+            host: pghost,
+            port: pgport,
+            username: pguser,
+            password: pgpassword,
+            database: pgdatabase,
+            ..Default::default()
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    static ENV_MUTEX: Mutex<()> = Mutex::new(());
+
+    const ALL_VARS: &[&str] = &[
+        "DATABASE_URL",
+        "PGHOST",
+        "PGPORT",
+        "PGUSER",
+        "PGPASSWORD",
+        "PGDATABASE",
+    ];
+
+    fn clear_env_vars() {
+        for var in ALL_VARS {
+            unsafe {
+                std::env::remove_var(var);
+            }
+        }
+    }
+
+    #[test]
+    fn from_env_none_when_no_vars_set() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        clear_env_vars();
+
+        assert!(PartialDatabaseConfiguration::from_env().is_none());
+    }
+
+    #[test]
+    fn from_env_all_vars_set() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        clear_env_vars();
+
+        unsafe {
+            std::env::set_var("DATABASE_URL", "postgres://u:p@h:1234/d");
+            std::env::set_var("PGHOST", "myhost");
+            std::env::set_var("PGPORT", "5433");
+            std::env::set_var("PGUSER", "myuser");
+            std::env::set_var("PGPASSWORD", "mypass");
+            std::env::set_var("PGDATABASE", "mydb");
+        }
+
+        let config = PartialDatabaseConfiguration::from_env().unwrap();
+        assert_eq!(
+            config.connection_string,
+            Some("postgres://u:p@h:1234/d".to_string())
+        );
+        assert_eq!(config.host, Some("myhost".to_string()));
+        assert_eq!(config.port, Some(5433));
+        assert_eq!(config.username, Some("myuser".to_string()));
+        assert_eq!(config.password, Some("mypass".to_string()));
+        assert_eq!(config.database, Some("mydb".to_string()));
+
+        clear_env_vars();
+    }
+
+    #[test]
+    fn from_env_partial_vars() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        clear_env_vars();
+
+        unsafe {
+            std::env::set_var("PGHOST", "remotehost");
+            std::env::set_var("PGDATABASE", "appdb");
+        }
+
+        let config = PartialDatabaseConfiguration::from_env().unwrap();
+        assert_eq!(config.connection_string, None);
+        assert_eq!(config.host, Some("remotehost".to_string()));
+        assert_eq!(config.port, None);
+        assert_eq!(config.username, None);
+        assert_eq!(config.password, None);
+        assert_eq!(config.database, Some("appdb".to_string()));
+
+        clear_env_vars();
+    }
+
+    #[test]
+    fn from_env_invalid_pgport_ignored() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        clear_env_vars();
+
+        unsafe {
+            std::env::set_var("PGHOST", "localhost");
+            std::env::set_var("PGPORT", "not_a_number");
+        }
+
+        let config = PartialDatabaseConfiguration::from_env().unwrap();
+        assert_eq!(config.host, Some("localhost".to_string()));
+        assert_eq!(config.port, None);
+
+        clear_env_vars();
+    }
+
+    #[test]
+    fn from_env_only_invalid_pgport_returns_none() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        clear_env_vars();
+
+        unsafe {
+            std::env::set_var("PGPORT", "not_a_number");
+        }
+
+        // PGPORT is set but invalid — parse fails so it becomes None.
+        // No other vars are set, so has_any is false.
+        assert!(PartialDatabaseConfiguration::from_env().is_none());
+
+        clear_env_vars();
+    }
+}

crates/pgls_env/src/lib.rs

@@ -35,6 +35,14 @@ pub struct PgLSEnv {
     pub pgls_log_prefix: PgLSEnvVariable,
     pub pgls_config_path: PgLSEnvVariable,
 
+    // Standard Postgres connection env vars
+    pub database_url: PgLSEnvVariable,
+    pub pghost: PgLSEnvVariable,
+    pub pgport: PgLSEnvVariable,
+    pub pguser: PgLSEnvVariable,
+    pub pgpassword: PgLSEnvVariable,
+    pub pgdatabase: PgLSEnvVariable,
+
     // DEPRECATED - kept for backward compatibility
     pub pgt_log_path: PgLSEnvVariable,
     pub pgt_log_level: PgLSEnvVariable,
@@ -64,6 +72,31 @@ impl PgLSEnv {
                 "A path to the configuration file",
             ),
 
+            database_url: PgLSEnvVariable::new(
+                "DATABASE_URL",
+                "A connection string that encodes the full database connection setup.",
+            ),
+            pghost: PgLSEnvVariable::new(
+                "PGHOST",
+                "The host of the database server.",
+            ),
+            pgport: PgLSEnvVariable::new(
+                "PGPORT",
+                "The port of the database server.",
+            ),
+            pguser: PgLSEnvVariable::new(
+                "PGUSER",
+                "The username to connect to the database.",
+            ),
+            pgpassword: PgLSEnvVariable::new(
+                "PGPASSWORD",
+                "The password to connect to the database.",
+            ),
+            pgdatabase: PgLSEnvVariable::new(
+                "PGDATABASE",
+                "The name of the database to connect to.",
+            ),
+
             pgt_log_path: PgLSEnvVariable::new(
                 "PGT_LOG_PATH",
                 "The directory where the Daemon logs will be saved. Deprecated, use PGLS_LOG_PATH instead.",
@@ -156,6 +189,24 @@ impl Display for PgLSEnv {
             }
         };
 
+        for var in [
+            &self.database_url,
+            &self.pghost,
+            &self.pgport,
+            &self.pguser,
+            &self.pgpassword,
+            &self.pgdatabase,
+        ] {
+            match var.value() {
+                None => {
+                    KeyValuePair(var.name, markup! { <Dim>"unset"</Dim> }).fmt(fmt)?;
+                }
+                Some(value) => {
+                    KeyValuePair(var.name, markup! {{DebugDisplay(value)}}).fmt(fmt)?;
+                }
+            };
+        }
+
         match self.pgt_log_path.value() {
             None => {
                 KeyValuePair(self.pgt_log_path.name, markup! { <Dim>"unset"</Dim> }).fmt(fmt)?;

crates/pgls_lsp/src/session.rs

@@ -7,6 +7,7 @@ use biome_deserialize::Merge;
 use futures::StreamExt;
 use futures::stream::FuturesUnordered;
 use pgls_analyse::RuleCategoriesBuilder;
+use pgls_configuration::database::PartialDatabaseConfiguration;
 use pgls_configuration::{ConfigurationPathHint, PartialConfiguration};
 use pgls_diagnostics::{DiagnosticExt, Error};
 use pgls_fs::{ConfigName, FileSystem, PgLSPath};
@@ -499,6 +500,13 @@ impl Session {
                     fs_configuration.merge_with(ws_configuration);
                 }
 
+                if let Some(env_db) = PartialDatabaseConfiguration::from_env() {
+                    match &mut fs_configuration.db {
+                        Some(db) => db.merge_with(env_db),
+                        None => fs_configuration.db = Some(env_db),
+                    }
+                }
+
                 let result = fs_configuration
                     .retrieve_gitignore_matches(&self.fs, configuration_path.as_deref());