feat(splinter): allow ignoring db objects

Cargo.toml

@@ -77,6 +77,7 @@ pgls_lexer                  = { path = "./crates/pgls_lexer", version = "0.0.0"
 pgls_lexer_codegen          = { path = "./crates/pgls_lexer_codegen", version = "0.0.0" }
 pgls_lsp                    = { path = "./crates/pgls_lsp", version = "0.0.0" }
 pgls_markup                 = { path = "./crates/pgls_markup", version = "0.0.0" }
+pgls_matcher                = { path = "./crates/pgls_matcher", version = "0.0.0" }
 pgls_plpgsql_check          = { path = "./crates/pgls_plpgsql_check", version = "0.0.0" }
 pgls_query                  = { path = "./crates/pgls_query", version = "0.0.0" }
 pgls_query_ext              = { path = "./crates/pgls_query_ext", version = "0.0.0" }

crates/pgls_configuration/Cargo.toml

@@ -22,6 +22,7 @@ pgls_analyser            = { workspace = true }
 pgls_console             = { workspace = true }
 pgls_diagnostics         = { workspace = true }
 pgls_env                 = { workspace = true }
+pgls_matcher             = { workspace = true }
 pgls_text_size           = { workspace = true }
 rustc-hash               = { workspace = true }
 schemars                 = { workspace = true, features = ["indexmap1"], optional = true }

crates/pgls_configuration/src/rules/configuration.rs

@@ -58,6 +58,15 @@ impl<T: Clone + Default + 'static> RuleConfiguration<T> {
         }
     }
 }
+impl<T: Default> RuleConfiguration<T> {
+    /// Get a reference to the typed options if present
+    pub fn get_options_ref(&self) -> Option<&T> {
+        match self {
+            Self::Plain(_) => None,
+            Self::WithOptions(options) => Some(&options.options),
+        }
+    }
+}
 impl<T: Default> Default for RuleConfiguration<T> {
     fn default() -> Self {
         Self::Plain(RulePlainConfiguration::Error)

crates/pgls_configuration/src/splinter/mod.rs

@@ -1,6 +1,8 @@
 //! Generated file, do not edit by hand, see `xtask/codegen`
 
 #![doc = r" Generated file, do not edit by hand, see `xtask/codegen`"]
+mod options;
+pub use options::SplinterRuleOptions;
 mod rules;
 use biome_deserialize::StringSet;
 use biome_deserialize_macros::{Merge, Partial};

crates/pgls_configuration/src/splinter/options.rs

@@ -0,0 +1,25 @@
+use biome_deserialize_macros::Deserializable;
+#[cfg(feature = "schema")]
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Shared options for all splinter rules.
+///
+/// These options allow configuring per-rule filtering of database objects.
+#[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, PartialEq, Serialize)]
+#[cfg_attr(feature = "schema", derive(JsonSchema))]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct SplinterRuleOptions {
+    /// A list of glob patterns for database objects to ignore.
+    ///
+    /// Patterns use Unix-style globs where:
+    /// - `*` matches any sequence of characters
+    /// - `?` matches any single character
+    ///
+    /// Each pattern should be in the format `schema.object_name`, for example:
+    /// - `"public.my_table"` - ignores a specific table
+    /// - `"audit.*"` - ignores all objects in the audit schema
+    /// - `"*.audit_*"` - ignores objects with audit_ prefix in any schema
+    #[serde(default)]
+    pub ignore: Vec<String>,
+}

crates/pgls_matcher/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+authors.workspace    = true
+categories.workspace = true
+description          = "Unix shell style pattern matching for Postgres Language Server"
+edition.workspace    = true
+homepage.workspace   = true
+keywords.workspace   = true
+license.workspace    = true
+name                 = "pgls_matcher"
+repository.workspace = true
+version              = "0.0.0"
+
+[dependencies]
+pgls_console     = { workspace = true }
+pgls_diagnostics = { workspace = true }
+rustc-hash       = { workspace = true }

crates/pgls_workspace/src/matcher/mod.rs → crates/pgls_matcher/src/lib.rs

@@ -135,8 +135,8 @@ impl Diagnostic for PatternError {
 
 #[cfg(test)]
 mod test {
-    use crate::matcher::Matcher;
-    use crate::matcher::pattern::MatchOptions;
+    use crate::Matcher;
+    use crate::pattern::MatchOptions;
     use std::env;
 
     #[test]
@@ -145,7 +145,7 @@ mod test {
         let dir = format!("{}/**/*.rs", current.display());
         let mut ignore = Matcher::new(MatchOptions::default());
         ignore.add_pattern(&dir).unwrap();
-        let path = env::current_dir().unwrap().join("src/workspace.rs");
+        let path = env::current_dir().unwrap().join("src/lib.rs");
         let result = ignore.matches(path.to_str().unwrap());
 
         assert!(result);
@@ -157,7 +157,7 @@ mod test {
         let dir = format!("{}/**/*.rs", current.display());
         let mut ignore = Matcher::new(MatchOptions::default());
         ignore.add_pattern(&dir).unwrap();
-        let path = env::current_dir().unwrap().join("src/workspace.rs");
+        let path = env::current_dir().unwrap().join("src/lib.rs");
         let result = ignore.matches_path(path.as_path());
 
         assert!(result);
@@ -184,14 +184,14 @@ mod test {
 
     #[test]
     fn matches_single_path() {
-        let dir = "workspace.rs";
+        let dir = "lib.rs";
         let mut ignore = Matcher::new(MatchOptions {
             require_literal_separator: true,
             case_sensitive: true,
             require_literal_leading_dot: true,
         });
         ignore.add_pattern(dir).unwrap();
-        let path = env::current_dir().unwrap().join("src/workspace.rs");
+        let path = env::current_dir().unwrap().join("src/lib.rs");
         let result = ignore.matches(path.to_str().unwrap());
 
         assert!(result);

crates/pgls_workspace/src/matcher/pattern.rs → crates/pgls_matcher/src/pattern.rs

@@ -1,8 +1,6 @@
-use crate::matcher::pattern::CharSpecifier::{CharRange, SingleChar};
-use crate::matcher::pattern::MatchResult::{
-    EntirePatternDoesntMatch, Match, SubPatternDoesntMatch,
-};
-use crate::matcher::pattern::PatternToken::{
+use crate::pattern::CharSpecifier::{CharRange, SingleChar};
+use crate::pattern::MatchResult::{EntirePatternDoesntMatch, Match, SubPatternDoesntMatch};
+use crate::pattern::PatternToken::{
     AnyChar, AnyExcept, AnyPattern, AnyRecursiveSequence, AnySequence, AnyWithin, Char,
 };
 use std::error::Error;

crates/pgls_splinter/Cargo.toml

@@ -11,12 +11,14 @@ repository.workspace = true
 version              = "0.0.0"
 
 [dependencies]
-pgls_analyse.workspace      = true
-pgls_diagnostics.workspace  = true
-pgls_schema_cache.workspace = true
-serde.workspace             = true
-serde_json.workspace        = true
-sqlx.workspace              = true
+pgls_analyse.workspace       = true
+pgls_configuration.workspace = true
+pgls_diagnostics.workspace   = true
+pgls_matcher.workspace       = true
+pgls_schema_cache.workspace  = true
+serde.workspace              = true
+serde_json.workspace         = true
+sqlx.workspace               = true
 
 [dev-dependencies]
 insta.workspace           = true

crates/pgls_splinter/src/lib.rs

@@ -6,6 +6,7 @@ pub mod rule;
 pub mod rules;
 
 use pgls_analyse::{AnalysisFilter, RegistryVisitor, RuleMeta};
+use pgls_configuration::splinter::Rules;
 use pgls_schema_cache::SchemaCache;
 use sqlx::PgPool;
 
@@ -17,6 +18,8 @@ pub use rule::SplinterRule;
 pub struct SplinterParams<'a> {
     pub conn: &'a PgPool,
     pub schema_cache: Option<&'a SchemaCache>,
+    /// Optional rules configuration for per-rule database object filtering
+    pub rules_config: Option<&'a Rules>,
 }
 
 /// Visitor that collects enabled splinter rules based on filter
@@ -134,7 +137,35 @@ pub async fn run_splinter(
     tx.commit().await?;
 
     // Convert results to diagnostics
-    let diagnostics: Vec<SplinterDiagnostic> = results.into_iter().map(Into::into).collect();
+    let mut diagnostics: Vec<SplinterDiagnostic> = results.into_iter().map(Into::into).collect();
+
+    // Apply per-rule object filtering if rules config is provided
+    if let Some(rules_config) = params.rules_config {
+        let rule_matchers = rules_config.get_ignore_matchers();
+
+        if !rule_matchers.is_empty() {
+            diagnostics.retain(|diag| {
+                // Extract rule name from category (e.g., "splinter/performance/noPrimaryKey" -> "noPrimaryKey")
+                let rule_name = diag.category.name().split('/').next_back().unwrap_or("");
+
+                // Look up pre-built matcher for this rule
+                if let Some(matcher) = rule_matchers.get(rule_name) {
+                    // Build object identifier from schema and name
+                    if let (Some(schema), Some(name)) =
+                        (&diag.advices.schema, &diag.advices.object_name)
+                    {
+                        let object_identifier = format!("{schema}.{name}");
+
+                        // If the object matches an ignore pattern, filter it out
+                        if matcher.matches(&object_identifier) {
+                            return false;
+                        }
+                    }
+                }
+                true
+            });
+        }
+    }
 
     Ok(diagnostics)
 }