Add ignore list to missing_fk_constraint check

Author: chaadow

lib/ruby-pg-extras.rb

@@ -7,6 +7,7 @@
 require "ruby_pg_extras/diagnose_data"
 require "ruby_pg_extras/diagnose_print"
 require "ruby_pg_extras/detect_fk_column"
+require "ruby_pg_extras/ignore_list"
 require "ruby_pg_extras/missing_fk_indexes"
 require "ruby_pg_extras/missing_fk_constraints"
 require "ruby_pg_extras/index_info"
@@ -195,7 +196,7 @@ def self.missing_fk_indexes(args: {}, in_format: :display_table)
   end
 
   def self.missing_fk_constraints(args: {}, in_format: :display_table)
-    RubyPgExtras::MissingFkConstraints.call(args[:table_name])
+    RubyPgExtras::MissingFkConstraints.call(args[:table_name], ignore_list: args[:ignore_list])
   end
 
   def self.display_result(result, title:, in_format:)

lib/ruby_pg_extras/ignore_list.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyPgExtras
+  # Parses and matches ignore patterns like:
+  # - "*"              (ignore everything)
+  # - "posts.*"        (ignore all columns on a table)
+  # - "category_id"    (ignore this column name on all tables)
+  # - "posts.topic_id" (ignore a specific table+column)
+  class IgnoreList
+    def initialize(ignore_list)
+      @rules = normalize(ignore_list)
+    end
+
+    def ignored?(table:, column_name:)
+      @rules.any? do |rule|
+        next true if rule == "*"
+        next true if rule == "#{table}.*"
+        next true if rule == column_name
+        next true if rule == "#{table}.#{column_name}"
+        false
+      end
+    end
+
+    private
+
+    def normalize(ignore_list)
+      entries =
+        case ignore_list
+        when nil
+          []
+        when String
+          ignore_list.split(",")
+        when Array
+          ignore_list
+        else
+          raise ArgumentError, "ignore_list must be a String or Array"
+        end
+
+      entries
+        .map { |v| v.to_s.strip }
+        .reject(&:empty?)
+        .uniq
+    end
+  end
+end
+
+

lib/ruby_pg_extras/missing_fk_constraints.rb

@@ -2,11 +2,17 @@
 
 module RubyPgExtras
   class MissingFkConstraints
-    def self.call(table_name)
-      new.call(table_name)
+    # ignore_list: array (or comma-separated string) of entries like:
+    # - "posts.category_id" (ignore a specific table+column)
+    # - "category_id"       (ignore this column name for all tables)
+    # - "posts.*"           (ignore all columns on a table)
+    def self.call(table_name, ignore_list: nil)
+      new.call(table_name, ignore_list: ignore_list)
     end
 
-    def call(table_name)
+    def call(table_name, ignore_list: nil)
+      ignore_list_matcher = IgnoreList.new(ignore_list)
+
       tables =
         if table_name
           [table_name]
@@ -26,10 +32,14 @@ def call(table_name)
       tables.each_with_object([]) do |table, agg|
         schema = schemas_by_table.fetch(table, [])
         fk_columns_for_table = fk_columns_by_table.fetch(table, [])
+        schema_column_names = schema.map { |row| row.fetch("column_name") }
 
         candidate_fk_columns = schema.filter_map do |row|
           column_name = row.fetch("column_name")
 
+          # Skip columns explicitly excluded via ignore list.
+          next if ignore_list_matcher.ignored?(table: table, column_name: column_name)
+
           # Skip columns that already have a foreign key constraint on this table.
           next if fk_columns_for_table.include?(column_name)
 
@@ -39,7 +49,6 @@ def call(table_name)
           # Rails polymorphic associations use <name>_id + <name>_type and can't have FK constraints.
           candidate_prefix = column_name.delete_suffix("_id")
           polymorphic_type_column = "#{candidate_prefix}_type"
-          schema_column_names = schema.map { |row| row.fetch("column_name") }
           # Skip polymorphic associations (cannot be expressed as a real FK constraint).
           next if schema_column_names.include?(polymorphic_type_column)
 

spec/ignore_list_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "ruby-pg-extras"
+
+describe RubyPgExtras::IgnoreList do
+  describe "#ignored?" do
+    it "returns false when ignore_list is nil" do
+      list = described_class.new(nil)
+      expect(list.ignored?(table: "posts", column_name: "topic_id")).to eq(false)
+    end
+
+    it "supports '*' to ignore everything" do
+      list = described_class.new(["*"])
+      expect(list.ignored?(table: "posts", column_name: "topic_id")).to eq(true)
+      expect(list.ignored?(table: "users", column_name: "customer_id")).to eq(true)
+    end
+
+    it "supports 'table.*' to ignore all columns for a table" do
+      list = described_class.new(["posts.*"])
+      expect(list.ignored?(table: "posts", column_name: "topic_id")).to eq(true)
+      expect(list.ignored?(table: "posts", column_name: "user_id")).to eq(true)
+      expect(list.ignored?(table: "users", column_name: "topic_id")).to eq(false)
+    end
+
+    it "supports 'column' to ignore a column name globally" do
+      list = described_class.new(["topic_id"])
+      expect(list.ignored?(table: "posts", column_name: "topic_id")).to eq(true)
+      expect(list.ignored?(table: "users", column_name: "topic_id")).to eq(true)
+      expect(list.ignored?(table: "posts", column_name: "user_id")).to eq(false)
+    end
+
+    it "supports 'table.column' to ignore a specific table+column" do
+      list = described_class.new(["posts.topic_id"])
+      expect(list.ignored?(table: "posts", column_name: "topic_id")).to eq(true)
+      expect(list.ignored?(table: "users", column_name: "topic_id")).to eq(false)
+      expect(list.ignored?(table: "posts", column_name: "user_id")).to eq(false)
+    end
+
+    it "accepts ignore_list as a comma-separated string" do
+      list = described_class.new("posts.topic_id, customer_id")
+      expect(list.ignored?(table: "posts", column_name: "topic_id")).to eq(true)
+      expect(list.ignored?(table: "users", column_name: "customer_id")).to eq(true)
+      expect(list.ignored?(table: "users", column_name: "topic_id")).to eq(false)
+    end
+
+    it "strips whitespace, drops empty entries and de-duplicates" do
+      list = described_class.new([" posts.topic_id ", "", "posts.topic_id", "  "])
+      expect(list.ignored?(table: "posts", column_name: "topic_id")).to eq(true)
+      expect(list.ignored?(table: "users", column_name: "topic_id")).to eq(false)
+    end
+
+    it "raises ArgumentError for unsupported ignore_list types" do
+      expect { described_class.new(123) }.to raise_error(ArgumentError)
+      expect { described_class.new({}) }.to raise_error(ArgumentError)
+    end
+  end
+end
+
+

spec/missing_fk_constraints_spec.rb

@@ -31,4 +31,26 @@
     result = RubyPgExtras.missing_fk_constraints(args: { table_name: "events" }, in_format: :hash)
     expect(result).to eq([])
   end
+
+  it "supports ignoring a specific table+column via args" do
+    result = RubyPgExtras.missing_fk_constraints(
+      args: { ignore_list: ["posts.category_id"] },
+      in_format: :hash
+    )
+
+    expect(result).to eq([
+      { table: "users", column_name: "customer_id" },
+    ])
+  end
+
+  it "supports ignoring a column name globally via args" do
+    result = RubyPgExtras.missing_fk_constraints(
+      args: { ignore_list: ["customer_id"] },
+      in_format: :hash
+    )
+
+    expect(result).to eq([
+      { table: "posts", column_name: "category_id" },
+    ])
+  end
 end