fix: address wasm pr feedback (#666)

Author: psteinroe

crates/pgls_cli/src/commands/mod.rs

@@ -158,7 +158,8 @@ pub enum PgLSCommand {
     /// Cleans the logs emitted by the daemon.
     Clean,
 
-    /// Exports the database schema to a JSON file for use with WASM bindings.
+    /// Exports the database schema to JSON for use with WASM bindings.
+    /// Writes to stdout by default, or to a file if --output is specified.
     #[bpaf(command("schema-export"))]
     SchemaExport {
         /// PostgreSQL connection string (e.g., postgres://user:pass@host/db)
@@ -170,14 +171,9 @@ pub enum PgLSCommand {
         )]
         connection_string: String,
 
-        /// Output file path for the JSON schema
-        #[bpaf(
-            long("output"),
-            short('o'),
-            argument("PATH"),
-            fallback(PathBuf::from("schema.json"))
-        )]
-        output: PathBuf,
+        /// Output file path for the JSON schema (defaults to stdout if not specified)
+        #[bpaf(long("output"), short('o'), argument("PATH"))]
+        output: Option<PathBuf>,
     },
 
     #[bpaf(command("__run_server"), hide)]

crates/pgls_cli/src/commands/schema_export.rs

@@ -1,29 +1,36 @@
 //! Schema export command for WASM bindings.
 //!
 //! This command connects to a PostgreSQL database and exports the schema cache
-//! as a JSON file that can be used with the WASM bindings.
+//! as JSON that can be used with the WASM bindings.
 
 use pgls_console::{ConsoleExt, EnvConsole, markup};
 use pgls_schema_cache::SchemaCache;
 use sqlx::postgres::PgPoolOptions;
+use std::io::Write;
 use std::path::Path;
 
 use crate::CliDiagnostic;
 
-/// Export the database schema to a JSON file.
+/// Export the database schema to JSON.
 ///
 /// # Arguments
 /// * `connection_string` - PostgreSQL connection string
-/// * `output_path` - Path to write the JSON output
+/// * `output_path` - Optional path to write the JSON output (stdout if None)
 pub async fn run_schema_export(
     connection_string: &str,
-    output_path: &Path,
+    output_path: Option<&Path>,
 ) -> Result<(), CliDiagnostic> {
     let mut console = EnvConsole::default();
 
-    console.log(markup! {
-        "Connecting to database..."
-    });
+    // Only print progress to stderr if we're writing to stdout,
+    // so the JSON output is clean and can be piped
+    let write_to_stdout = output_path.is_none();
+
+    if !write_to_stdout {
+        console.log(markup! {
+            "Connecting to database..."
+        });
+    }
 
     // Connect to the database
     let pool = PgPoolOptions::new()
@@ -36,9 +43,11 @@ pub async fn run_schema_export(
             )))
         })?;
 
-    console.log(markup! {
-        "Loading schema cache..."
-    });
+    if !write_to_stdout {
+        console.log(markup! {
+            "Loading schema cache..."
+        });
+    }
 
     // Load the schema cache
     let schema_cache = SchemaCache::load(&pool).await.map_err(|e| {
@@ -47,9 +56,11 @@ pub async fn run_schema_export(
         )))
     })?;
 
-    console.log(markup! {
-        "Serializing schema..."
-    });
+    if !write_to_stdout {
+        console.log(markup! {
+            "Serializing schema..."
+        });
+    }
 
     // Serialize to JSON
     let json = serde_json::to_string_pretty(&schema_cache).map_err(|e| {
@@ -58,33 +69,47 @@ pub async fn run_schema_export(
         )))
     })?;
 
-    // Write to file
-    std::fs::write(output_path, json).map_err(|e| {
-        CliDiagnostic::io_error(std::io::Error::other(format!(
-            "Failed to write output file: {e}"
-        )))
-    })?;
+    // Write output
+    if let Some(path) = output_path {
+        std::fs::write(path, &json).map_err(|e| {
+            CliDiagnostic::io_error(std::io::Error::other(format!(
+                "Failed to write output file: {e}"
+            )))
+        })?;
 
-    console.log(markup! {
-        "Schema exported to "<Emphasis>{output_path.display().to_string()}</Emphasis>
-    });
+        console.log(markup! {
+            "Schema exported to "<Emphasis>{path.display().to_string()}</Emphasis>
+        });
 
-    // Print summary
-    console.log(markup! {
-        "\nSchema summary:"
-    });
-    console.log(markup! {
-        "  Schemas: "{schema_cache.schemas.len().to_string()}
-    });
-    console.log(markup! {
-        "  Tables: "{schema_cache.tables.len().to_string()}
-    });
-    console.log(markup! {
-        "  Functions: "{schema_cache.functions.len().to_string()}
-    });
-    console.log(markup! {
-        "  Types: "{schema_cache.types.len().to_string()}
-    });
+        // Print summary
+        console.log(markup! {
+            "\nSchema summary:"
+        });
+        console.log(markup! {
+            "  Schemas: "{schema_cache.schemas.len().to_string()}
+        });
+        console.log(markup! {
+            "  Tables: "{schema_cache.tables.len().to_string()}
+        });
+        console.log(markup! {
+            "  Functions: "{schema_cache.functions.len().to_string()}
+        });
+        console.log(markup! {
+            "  Types: "{schema_cache.types.len().to_string()}
+        });
+    } else {
+        // Write to stdout
+        std::io::stdout().write_all(json.as_bytes()).map_err(|e| {
+            CliDiagnostic::io_error(std::io::Error::other(format!(
+                "Failed to write to stdout: {e}"
+            )))
+        })?;
+        std::io::stdout().write_all(b"\n").map_err(|e| {
+            CliDiagnostic::io_error(std::io::Error::other(format!(
+                "Failed to write to stdout: {e}"
+            )))
+        })?;
+    }
 
     Ok(())
 }

crates/pgls_cli/src/lib.rs

@@ -126,7 +126,7 @@ impl<'app> CliSession<'app> {
                 let runtime = tokio::runtime::Runtime::new().map_err(CliDiagnostic::io_error)?;
                 runtime.block_on(commands::schema_export::run_schema_export(
                     &connection_string,
-                    &output,
+                    output.as_deref(),
                 ))
             }
         };

crates/pgls_cli/src/metrics.rs

@@ -74,7 +74,7 @@ impl CallsiteEntry {
         }
     }
 
-    fn into_histograms(self, name: &str) -> Vec<(Cow<str>, Histogram<u64>)> {
+    fn into_histograms(self, name: &str) -> Vec<(Cow<'_, str>, Histogram<u64>)> {
         match self {
             CallsiteEntry::Debug { total } => vec![(Cow::Borrowed(name), total)],
             CallsiteEntry::Trace { total, busy, idle } => vec![

crates/pgls_console/src/markup.rs

@@ -205,11 +205,11 @@ impl Write for MarkupBuf {
             Ok(())
         })?;
 
-        if let Some(last) = self.0.last_mut() {
-            if last.elements == styles {
-                last.content.push_str(content);
-                return Ok(());
-            }
+        if let Some(last) = self.0.last_mut()
+            && last.elements == styles
+        {
+            last.content.push_str(content);
+            return Ok(());
         }
 
         self.0.push(MarkupNodeBuf {
@@ -227,11 +227,11 @@ impl Write for MarkupBuf {
             Ok(())
         })?;
 
-        if let Some(last) = self.0.last_mut() {
-            if last.elements == styles {
-                last.content.push_str(&content.to_string());
-                return Ok(());
-            }
+        if let Some(last) = self.0.last_mut()
+            && last.elements == styles
+        {
+            last.content.push_str(&content.to_string());
+            return Ok(());
         }
 
         self.0.push(MarkupNodeBuf {

crates/pgls_diagnostics/src/display/backtrace.rs

@@ -163,10 +163,10 @@ impl NativeBacktrace {
             })
         });
 
-        if let Some(top_frame) = top_frame {
-            if let Some(bottom_frames) = frames.get(top_frame + 1..) {
-                frames = bottom_frames;
-            }
+        if let Some(top_frame) = top_frame
+            && let Some(bottom_frames) = frames.get(top_frame + 1..)
+        {
+            frames = bottom_frames;
         }
 
         let bottom_frame = frames.iter().position(|frame| {
@@ -177,10 +177,10 @@ impl NativeBacktrace {
             })
         });
 
-        if let Some(bottom_frame) = bottom_frame {
-            if let Some(top_frames) = frames.get(..bottom_frame + 1) {
-                frames = top_frames;
-            }
+        if let Some(bottom_frame) = bottom_frame
+            && let Some(top_frames) = frames.get(..bottom_frame + 1)
+        {
+            frames = top_frames;
         }
 
         frames

crates/pgls_workspace/src/settings.rs

@@ -293,12 +293,12 @@ impl Settings {
     }
 
     /// Returns linter rules.
-    pub fn as_linter_rules(&self) -> Option<Cow<pgls_configuration::linter::Rules>> {
+    pub fn as_linter_rules(&self) -> Option<Cow<'_, pgls_configuration::linter::Rules>> {
         self.linter.rules.as_ref().map(Cow::Borrowed)
     }
 
     /// Returns splinter rules.
-    pub fn as_splinter_rules(&self) -> Option<Cow<pgls_configuration::splinter::Rules>> {
+    pub fn as_splinter_rules(&self) -> Option<Cow<'_, pgls_configuration::splinter::Rules>> {
         self.splinter.rules.as_ref().map(Cow::Borrowed)
     }
 

crates/pgls_workspace/src/workspace/server.rs

@@ -124,11 +124,11 @@ impl WorkspaceServer {
     }
 
     /// Provides a reference to the current settings
-    fn workspaces(&self) -> WorkspaceSettingsHandle {
+    fn workspaces(&self) -> WorkspaceSettingsHandle<'_> {
         WorkspaceSettingsHandle::new(&self.settings)
     }
 
-    fn workspaces_mut(&self) -> WorkspaceSettingsHandleMut {
+    fn workspaces_mut(&self) -> WorkspaceSettingsHandleMut<'_> {
         WorkspaceSettingsHandleMut::new(&self.settings)
     }
 
@@ -500,8 +500,10 @@ impl Workspace for WorkspaceServer {
     #[cfg(feature = "db")]
     fn invalidate_schema_cache(&self, all: bool) -> Result<(), WorkspaceError> {
         if all {
-            // Clear all db-loaded schemas (keep json schema since it was explicitly set)
-            self.schema_cache.clear_all_connections();
+            // Clear all schemas - both db-loaded and json-loaded
+            // DB completions always take precedence when a connection is available,
+            // so clearing the json schema keeps behavior consistent
+            self.schema_cache.clear_all();
         } else {
             // Only clear current connection if one exists
             if let Some(pool) = self.get_current_connection() {

crates/pgls_workspace/src/workspace/server/analyser.rs

@@ -50,7 +50,6 @@ impl<'a> AnalyserVisitorBuilder<'a> {
         self
     }
 
-    #[cfg(feature = "db")]
     #[must_use]
     pub(crate) fn finish(self) -> (Vec<RuleFilter<'static>>, Vec<RuleFilter<'static>>) {
         let mut disabled_rules = vec![];
@@ -61,6 +60,7 @@ impl<'a> AnalyserVisitorBuilder<'a> {
             enabled_rules.extend(linter_enabled_rules);
             disabled_rules.extend(linter_disabled_rules);
         }
+        #[cfg(feature = "db")]
         if let Some(mut splinter) = self.splinter {
             pgls_splinter::registry::visit_registry(&mut splinter);
             let (splinter_enabled_rules, splinter_disabled_rules) = splinter.finish();
@@ -70,21 +70,6 @@ impl<'a> AnalyserVisitorBuilder<'a> {
 
         (enabled_rules, disabled_rules)
     }
-
-    #[cfg(not(feature = "db"))]
-    #[must_use]
-    pub(crate) fn finish(self) -> (Vec<RuleFilter<'static>>, Vec<RuleFilter<'static>>) {
-        let mut disabled_rules = vec![];
-        let mut enabled_rules = vec![];
-        if let Some(mut lint) = self.lint {
-            pgls_analyser::visit_registry(&mut lint);
-            let (linter_enabled_rules, linter_disabled_rules) = lint.finish();
-            enabled_rules.extend(linter_enabled_rules);
-            disabled_rules.extend(linter_disabled_rules);
-        }
-
-        (enabled_rules, disabled_rules)
-    }
 }
 
 /// Type meant to register all the lint rules

docs/codegen/src/rules_index.rs

@@ -78,7 +78,7 @@ fn generate_group(
     Ok(())
 }
 
-fn extract_group_metadata(group: &str) -> (&str, Markup) {
+fn extract_group_metadata(group: &str) -> (&str, Markup<'_>) {
     match group {
         "safety" => (
             "Safety",