refactor: move env var config to ServerFactory/Session lifecycle

Env config is computed once at ServerFactory creation and threaded
through to Session, which merges it as the highest-priority layer
during config loading. Tests use ServerFactory::default() which
provides None, avoiding DATABASE_URL interference from sqlx::test.

Author: psteinroe

crates/pgls_lsp/src/server.rs

@@ -6,6 +6,7 @@ use crate::session::{
 use crate::utils::{into_lsp_error, panic_to_lsp_error};
 use futures::FutureExt;
 use futures::future::ready;
+use pgls_configuration::database::PartialDatabaseConfiguration;
 use pgls_fs::{ConfigName, FileSystem, OsFileSystem};
 use pgls_workspace::workspace::{RegisterProjectFolderParams, UnregisterProjectFolderParams};
 use pgls_workspace::{DynRef, Workspace, workspace};
@@ -92,6 +93,7 @@ impl LSPServer {
 
         self.session.register_capabilities(capabilities).await;
     }
+
 }
 
 #[tower_lsp::async_trait]
@@ -162,8 +164,10 @@ impl LanguageServer for LSPServer {
 
     #[tracing::instrument(level = "info", skip_all)]
     async fn did_change_configuration(&self, params: DidChangeConfigurationParams) {
+        let extra_config: Option<pgls_configuration::PartialConfiguration> =
+            serde_json::from_value(params.settings).ok();
         self.session
-            .load_workspace_settings(serde_json::from_value(params.settings).ok())
+            .load_workspace_settings(extra_config)
             .await;
         self.setup_capabilities().await;
         self.session.update_all_diagnostics().await;
@@ -410,17 +414,26 @@ pub struct ServerFactory {
     /// This shared flag is set to true once at least one sessions has been
     /// initialized on this server instance
     is_initialized: Arc<AtomicBool>,
+    /// Configuration from environment variables (DATABASE_URL, PGHOST, etc.).
+    /// Computed once at factory creation and passed to each session.
+    env_config: Option<pgls_configuration::PartialConfiguration>,
 }
 
 impl ServerFactory {
     pub fn new(stop_on_disconnect: bool) -> Self {
+        let env_config =
+            PartialDatabaseConfiguration::from_env().map(|db| pgls_configuration::PartialConfiguration {
+                db: Some(db),
+                ..Default::default()
+            });
         Self {
             cancellation: Arc::default(),
             workspace: None,
             sessions: Sessions::default(),
             next_session_key: AtomicU64::new(0),
             stop_on_disconnect,
             is_initialized: Arc::default(),
+            env_config,
         }
     }
 
@@ -441,13 +454,15 @@ impl ServerFactory {
 
         let session_key = SessionKey(self.next_session_key.fetch_add(1, Ordering::Relaxed));
 
+        let env_config = self.env_config.clone();
         let mut builder = LspService::build(move |client| {
             let mut session = Session::new(
                 session_key,
                 client,
                 workspace,
                 self.cancellation.clone(),
                 fs,
+                env_config,
             );
             if let Some(path) = config_path {
                 session.set_config_path(path);

crates/pgls_lsp/src/session.rs

@@ -7,7 +7,6 @@ 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};
@@ -76,6 +75,9 @@ pub(crate) struct Session {
     pub(crate) cancellation: Arc<Notify>,
 
     pub(crate) config_path: Option<PathBuf>,
+
+    /// Extra configuration from environment variables, applied on every config load.
+    env_config: Option<PartialConfiguration>,
 }
 
 /// The parameters provided by the client in the "initialize" request
@@ -156,6 +158,7 @@ impl Session {
         workspace: Arc<dyn Workspace>,
         cancellation: Arc<Notify>,
         fs: DynRef<'static, dyn FileSystem>,
+        env_config: Option<PartialConfiguration>,
     ) -> Self {
         let documents = Default::default();
         Self {
@@ -170,6 +173,7 @@ impl Session {
             config_path: None,
             notified_broken_configuration: AtomicBool::new(false),
             notified_deprecated_config: AtomicBool::new(false),
+            env_config,
         }
     }
 
@@ -500,11 +504,9 @@ 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),
-                    }
+                // Env vars take highest priority — merge last so they override everything.
+                if let Some(env_config) = &self.env_config {
+                    fs_configuration.merge_with(env_config.clone());
                 }
 
                 let result = fs_configuration