database_consistency 2.0.4 → 3.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60ddbdae671fab802b24773279d1f669f2ebe5303e7836f8ea73aebbabd34386
-  data.tar.gz: 1bb99a2ac677ff177d33c8ff38b052899d8da6dbb8eed842dcd2b6ce0a24a763
+  metadata.gz: f88fd56f01f639d5614fa82f5e76f6d4a4dfb05c04c246f5baeedf93fd01fe24
+  data.tar.gz: 0bb41479e542c995569b54a6cfc188ea39103c30a074560f0bae15f8223c1128
 SHA512:
-  metadata.gz: f0121b1c39050c29c03b018d30ea28e7eed0d80a5a5e1b13dedfd985a93cb1b4a70e879e0bb1cfb816e6ddeffce0a9b1afa74f95845ce6c9c192a2ef0393d6de
-  data.tar.gz: 6c891974af21502183d550dee005ee5c9266033261285fb4e21809beccb17e7f38cecdcbb3038d3336f41fd1c1ab7950d9a19bf603c9dd07b282a56cf37c4696
+  metadata.gz: 54baea922639aec00a1c1edb9aaef5e0d70ec91a2ce63552fcb2ab502b93c1a2779c3227fdb55c7cb03afd17a346624cfc192d84c07480583b44bba00554eea5
+  data.tar.gz: 69a60f5b359e2bfc89765756115e510646d6167fd2819da7f25451302c52f1f54c2c590e1a487eb2291c9e747a54e80bf4e193b9db506bc13f8cc7a580b0be8c

data/bin/database_consistency

@@ -39,10 +39,17 @@ opt_parser = OptionParser.new do |opts|
     options[:todo] = true
   end
 
-  opts.on('-f', '--autofix', 'Automatically fixes issues by adjusting the code or generating missing migrations.') do
+  opts.on('-f', '--autofix',
+          'Automatically fixes issues by adjusting the code or generating missing migrations.') do
     options[:autofix] = true
   end
 
+  opts.on('--only-checkers=LIST', Array,
+          'When used with --autofix, restricts the fix to offenses produced by the listed checker ' \
+          'class names (comma-separated, e.g. ColumnPresenceChecker,NullConstraintChecker).') do |checkers|
+    options[:only_checkers] = checkers
+  end
+
   opts.on('-h', '--help', 'Prints this help.') do
     puts opts
     exit
@@ -51,6 +58,11 @@ end
 
 opt_parser.parse!
 
+if options[:only_checkers] && !options[:autofix]
+  warn '--only-checkers requires --autofix'
+  exit 1
+end
+
 base_dir = File.join(Dir.pwd, ARGV.first.to_s)
 unless File.realpath(base_dir).start_with?(Dir.pwd)
   puts "\nWarning! You are going out of current directory, ruby version may be wrong and some gems may be missing.\n"
@@ -75,5 +87,10 @@ $LOAD_PATH.unshift(File.expand_path('lib', __dir__))
 require 'database_consistency'
 
 # Process checks
-code = DatabaseConsistency.run(config, **options)
+begin
+  code = DatabaseConsistency.run(config, **options)
+rescue DatabaseConsistency::Writers::AutofixWriter::UnknownCheckerError => e
+  warn e.message
+  exit 1
+end
 exit code

data/lib/database_consistency/checkers/association_checkers/association_checker.rb

@@ -6,6 +6,10 @@ module DatabaseConsistency
     class AssociationChecker < BaseChecker
       attr_reader :model, :association
 
+      def self.processor
+        Processors::AssociationsProcessor
+      end
+
       def initialize(model, association)
         super()
         @model = model
@@ -19,6 +23,13 @@ module DatabaseConsistency
       def table_or_model_name
         @table_or_model_name ||= model.name.to_s
       end
+
+      def foreign_key # rubocop:disable Metrics/AbcSize
+        model.connection.foreign_keys(model.table_name).find do |foreign_key|
+          (Helper.extract_columns(association.foreign_key) - Array.wrap(foreign_key.column)).empty? &&
+            foreign_key.to_table == association.klass.table_name
+        end
+      end
     end
   end
 end

data/lib/database_consistency/checkers/association_checkers/foreign_key_cascade_checker.rb

@@ -28,6 +28,7 @@ module DatabaseConsistency
       def preconditions
         !association.polymorphic? &&
           !association.belongs_to? &&
+          association.association_primary_key.present? &&
           foreign_key &&
           DEPENDENT_OPTIONS.include?(dependent_option)
       rescue StandardError
@@ -68,18 +69,18 @@ module DatabaseConsistency
           association.klass
                      .connection
                      .foreign_keys(association.klass.table_name)
-                     .find { |fk| fk.column == association.foreign_key.to_s }
+                     .find { |fk| (Helper.extract_columns(association.foreign_key) - Array.wrap(fk.column)).empty? }
       end
 
-      def report_template(status, error_slug: nil)
+      def report_template(status, error_slug: nil) # rubocop:disable Metrics/AbcSize
         Report.new(
           status: status,
           error_message: nil,
           error_slug: error_slug,
           primary_table: association.table_name.to_s,
-          primary_key: association.association_primary_key.to_s,
+          primary_key: Helper.extract_columns(association.association_primary_key).join('+'),
           foreign_table: association.active_record.table_name.to_s,
-          foreign_key: association.foreign_key.to_s,
+          foreign_key: Helper.extract_columns(association.foreign_key).join('+'),
           cascade_option: required_foreign_key_cascade,
           **report_attributes
         )

data/lib/database_consistency/checkers/association_checkers/foreign_key_checker.rb

@@ -43,7 +43,7 @@ module DatabaseConsistency
       # | persisted   | ok     |
       # | missing     | fail   |
       def check
-        if model.connection.foreign_keys(model.table_name).find { |fk| fk.column == association.foreign_key.to_s }
+        if foreign_key
           report_template(:ok)
         else
           report_template(:fail, error_slug: :missing_foreign_key)

data/lib/database_consistency/checkers/association_checkers/foreign_key_type_checker.rb

@@ -3,7 +3,7 @@
 module DatabaseConsistency
   module Checkers
     # This class checks if association's foreign key type covers associated model's primary key (same or bigger)
-    class ForeignKeyTypeChecker < AssociationChecker
+    class ForeignKeyTypeChecker < AssociationChecker # rubocop:disable Metrics/ClassLength
       Report = ReportBuilder.define(
         DatabaseConsistency::Report,
         :pk_name,
@@ -36,10 +36,11 @@ module DatabaseConsistency
       # | ------------- | ------ |
       # | covers        | ok     |
       # | doesn't cover | fail   |
-      def check # rubocop:disable Metrics/MethodLength,  Metrics/AbcSize
-        if converted_type(associated_column).cover?(converted_type(primary_column))
-          report_template(:ok)
-        elsif !(converted_type(associated_column).numeric? && converted_type(primary_column).numeric?)
+      def check # rubocop:disable Metrics/MethodLength
+        associated_columns_converted_types = associated_columns.map { |column| converted_type(column) }
+        primary_columns_converted_types = primary_columns.map { |primary_column| converted_type(primary_column) }
+
+        if covers?(associated_columns_converted_types, primary_columns_converted_types)
           report_template(:ok)
         else
           report_template(:fail, error_slug: :inconsistent_types)
@@ -53,17 +54,17 @@ module DatabaseConsistency
         )
       end
 
-      def report_template(status, error_slug: nil) # rubocop:disable Metrics/MethodLength
+      def report_template(status, error_slug: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         Report.new(
           status: status,
           error_slug: error_slug,
           error_message: nil,
           table_to_change: table_to_change,
-          type_to_set: converted_type(primary_column).convert,
-          fk_type: converted_type(associated_column).type,
-          fk_name: associated_key,
-          pk_type: converted_type(primary_column).type,
-          pk_name: primary_key,
+          type_to_set: primary_columns.map { |primary_column| converted_type(primary_column).convert },
+          fk_type: associated_columns.map { |column| converted_type(column).type }.join('+'),
+          fk_name: associated_keys.join('+'),
+          pk_type: primary_columns.map { |primary_column| converted_type(primary_column).type }.join('+'),
+          pk_name: primary_keys.join('+'),
           **report_attributes
         )
       end
@@ -76,36 +77,40 @@ module DatabaseConsistency
                              end
       end
 
-      # @return [String]
-      def primary_key
-        @primary_key ||= if belongs_to_association?
-                           association.association_primary_key
-                         else
-                           association.active_record_primary_key
-                         end.to_s
+      # @return [Array<String>]
+      def primary_keys
+        @primary_keys ||= if belongs_to_association?
+                            Helper.extract_columns(association.association_primary_key)
+                          else
+                            Helper.extract_columns(association.active_record_primary_key)
+                          end
       end
 
-      # @return [String]
-      def associated_key
-        @associated_key ||= association.foreign_key.to_s
+      # @return [Array<String>]
+      def associated_keys
+        @associated_keys ||= Helper.extract_columns(association.foreign_key)
       end
 
-      # @return [ActiveRecord::ConnectionAdapters::Column]
-      def primary_column
-        @primary_column ||= if belongs_to_association?
-                              column(association.klass, primary_key)
-                            else
-                              column(association.active_record, primary_key)
-                            end
+      # @return [Array<ActiveRecord::ConnectionAdapters::Column>]
+      def primary_columns
+        @primary_columns ||= primary_keys.map do |primary_key|
+          if belongs_to_association?
+            column(association.klass, primary_key)
+          else
+            column(association.active_record, primary_key)
+          end
+        end
       end
 
-      # @return [ActiveRecord::ConnectionAdapters::Column]
-      def associated_column
-        @associated_column ||= if belongs_to_association?
-                                 column(association.active_record, associated_key)
-                               else
-                                 column(association.klass, associated_key)
-                               end
+      # @return [Array<ActiveRecord::ConnectionAdapters::Column>]
+      def associated_columns
+        @associated_columns ||= associated_keys.map do |associated_key|
+          if belongs_to_association?
+            column(association.active_record, associated_key)
+          else
+            column(association.klass, associated_key)
+          end
+        end
       end
 
       # @return [DatabaseConsistency::Databases::Factory]
@@ -135,6 +140,12 @@ module DatabaseConsistency
         column.sql_type
       end
 
+      def covers?(associated_types, primary_types)
+        associated_types.zip(primary_types).all? do |associated_type, primary_type|
+          associated_type.cover?(primary_type)
+        end
+      end
+
       # @param [ActiveRecord::ConnectionAdapters::Column]
       #
       # @return [DatabaseConsistency::Databases::Types::Base]

data/lib/database_consistency/checkers/association_checkers/missing_dependent_destroy_checker.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Checkers
+    # This class checks for models that need a dependent destroy association
+    class MissingDependentDestroyChecker < AssociationChecker
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :model_name,
+        :attribute_name
+      )
+
+      DEPENDENT_OPTIONS = %i[destroy delete delete_all nullify restrict_with_error restrict_with_exception].freeze
+
+      private
+
+      def preconditions
+        association.belongs_to? && !association.polymorphic? && foreign_key
+      end
+
+      def check
+        if dependent_destroy_exists? || cascade?
+          report_template(:ok)
+        else
+          report_template(:fail, error_slug: :missing_dependent_destroy)
+        end
+      end
+
+      def dependent_destroy_exists?
+        association.klass.reflect_on_all_associations.any? do |association|
+          %i[has_many has_one].include?(association.macro) &&
+            DEPENDENT_OPTIONS.include?(association.options[:dependent]) &&
+            association.table_name == model.table_name
+        end
+      end
+
+      def cascade?
+        %i[cascade nullify].include? foreign_key.options[:on_delete]
+      end
+
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_message: nil,
+          error_slug: error_slug,
+          model_name: association.class_name,
+          attribute_name: model.table_name,
+          **report_attributes
+        )
+      end
+    end
+  end
+end

data/lib/database_consistency/checkers/base_checker.rb

@@ -16,8 +16,7 @@ module DatabaseConsistency
 
         return if subclass.superclass.name == 'DatabaseConsistency::Checkers::BaseChecker'
 
-        processor_prefix = subclass.superclass.name.demodulize.delete_suffix('Checker').pluralize
-        processor = "DatabaseConsistency::Processors::#{processor_prefix}Processor".constantize
+        processor = subclass.processor
         processor.checkers << subclass
       end
 

data/lib/database_consistency/checkers/column_checkers/column_checker.rb

@@ -6,6 +6,10 @@ module DatabaseConsistency
     class ColumnChecker < BaseChecker
       attr_reader :model, :column
 
+      def self.processor
+        Processors::ColumnsProcessor
+      end
+
       def initialize(model, column)
         super()
         @model = model

data/lib/database_consistency/checkers/column_checkers/missing_index_find_by_checker.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+begin
+  require 'prism'
+rescue LoadError
+  # Prism is not available; this checker will be disabled on Ruby < 3.3
+end
+
+module DatabaseConsistency
+  module Checkers
+    # This class checks for columns used in find_by queries that are missing a database index.
+    # It uses the Prism parser (Ruby stdlib since 3.3) to traverse the AST of all project
+    # source files (found by iterating loaded constants and excluding gem paths) and detect
+    # calls such as find_by_<column>, find_by(column: ...) and find_by("column" => ...).
+    # The checker is automatically skipped on Ruby versions where Prism is not available.
+    class MissingIndexFindByChecker < ColumnChecker
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :source_location,
+        :total_findings_count
+      )
+
+      private
+
+      # We skip check when:
+      #  - Prism is not available (Ruby < 3.3)
+      #  - column is the primary key (always indexed)
+      #  - column is a boolean (low-cardinality; single-column indexes are rarely useful)
+      #  - column name does not appear in any find_by call across project source files
+      def preconditions
+        defined?(Prism) && !primary_key_column? && !boolean_column? && find_by_used?
+      end
+
+      # Table of possible statuses
+      # | index    | status |
+      # | -------- | ------ |
+      # | present  | ok     |
+      # | missing  | fail   |
+      def check
+        if indexed?
+          report_template(:ok)
+        else
+          report_template(:fail, error_slug: :missing_index_find_by)
+        end
+      end
+
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          source_location: (status == :fail ? @find_by_location : nil),
+          total_findings_count: (status == :fail ? @find_by_count : nil),
+          **report_attributes
+        )
+      end
+
+      def find_by_used?
+        entry = PrismHelper.find_by_calls_index.dig(model.name.to_s, column.name.to_s)
+        return false unless entry
+
+        @find_by_location = entry[:first_location]
+        @find_by_count = entry[:total_findings_count]
+        true
+      end
+
+      def indexed?
+        model.connection.indexes(model.table_name).any? do |index|
+          Helper.extract_index_columns(index.columns).first == column.name.to_s
+        end
+      end
+
+      def primary_key_column?
+        column.name.to_s == model.primary_key.to_s
+      end
+
+      def boolean_column?
+        column.type == :boolean
+      end
+
+      if defined?(Prism)
+        # Prism AST visitor that collects ALL find_by calls from a source file into a results hash.
+        # Key: [model_name, column_name] -- model_name is derived from the explicit receiver or the
+        # lexical class/module scope for bare calls. Bare calls outside any class are ignored.
+        # Value: "file:line" location of the first matching call.
+        #
+        # Handles:
+        #  - find_by_<col>(<value>) / Model.find_by_<col>!  (dynamic finder)
+        #  - find_by(col: <value>) / Model.find_by col:     (symbol-key hash)
+        #  - find_by("col" => <value>)                      (string-key hash)
+        #
+        # Defined only when Prism is available (Ruby 3.3+).
+        class FindByCollector < Prism::Visitor
+          # Matches the full column name from a dynamic finder method name.
+          # e.g. find_by_email -> "email", find_by_first_name -> "first_name"
+          # Multi-column patterns like find_by_name_and_email extract "name_and_email"
+          # which won't match any single-column name, so there are no false positives.
+          DYNAMIC_FINDER_RE = /\Afind_by_(.+?)!?\z/.freeze
+
+          attr_reader :results
+
+          def initialize(file)
+            super()
+            @file = file
+            @results = {}
+            @scope_stack = []
+          end
+
+          def visit_class_node(node)
+            @scope_stack.push(constant_path_name(node.constant_path))
+            super
+          ensure
+            @scope_stack.pop
+          end
+
+          def visit_module_node(node)
+            @scope_stack.push(constant_path_name(node.constant_path))
+            super
+          ensure
+            @scope_stack.pop
+          end
+
+          def visit_call_node(node)
+            name = node.name.to_s
+            if (match = DYNAMIC_FINDER_RE.match(name))
+              model_key = receiver_to_model_key(node.receiver)
+              store(model_key, match[1], node) unless model_key == :skip
+            elsif name == 'find_by' && node.arguments
+              col = single_hash_column(node.arguments)
+              model_key = receiver_to_model_key(node.receiver)
+              store(model_key, col, node) if col && model_key != :skip
+            end
+            super
+          end
+
+          private
+
+          def current_scope
+            @scope_stack.empty? ? nil : @scope_stack.join('::')
+          end
+
+          def store(model_key, col, node)
+            key = [model_key, col]
+            @results[key] ||= []
+            @results[key] << "#{@file}:#{node.location.start_line}"
+          end
+
+          def receiver_to_model_key(receiver)
+            case receiver
+            when nil then current_scope || :skip
+            when Prism::ConstantReadNode, Prism::ConstantPathNode
+              constant_path_name(receiver)
+            when Prism::CallNode
+              scoped_receiver_model(receiver)
+            else
+              :skip
+            end
+          end
+
+          def scoped_receiver_model(call_node)
+            return :skip unless %w[unscoped includes].include?(call_node.name.to_s)
+
+            rec = call_node.receiver
+            return :skip unless rec.is_a?(Prism::ConstantReadNode) || rec.is_a?(Prism::ConstantPathNode)
+
+            constant_path_name(rec)
+          end
+
+          def constant_path_name(node)
+            case node
+            when Prism::ConstantReadNode then node.name.to_s
+            when Prism::ConstantPathNode then "#{constant_path_name(node.parent)}::#{node.name}"
+            end
+          end
+
+          def single_hash_column(arguments_node)
+            arguments_node.arguments.each do |arg|
+              next unless arg.is_a?(Prism::KeywordHashNode) && arg.elements.size == 1
+
+              assoc = arg.elements.first
+              next unless assoc.is_a?(Prism::AssocNode)
+
+              key = assoc.key
+              return key.unescaped if key.is_a?(Prism::SymbolNode) || key.is_a?(Prism::StringNode)
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/checkers/column_checkers/null_constraint_checker.rb

@@ -69,7 +69,7 @@ module DatabaseConsistency
         model.validators.any? do |validator|
           validator.kind == :exclusion &&
             Helper.check_inclusion?(validator.attributes, column.name) &&
-            validator.options[:in].include?(nil)
+            Helper.inclusion_validator_values(validator).include?(nil)
         end
       end
 

data/lib/database_consistency/checkers/enum_checkers/enum_checker.rb

@@ -6,6 +6,10 @@ module DatabaseConsistency
     class EnumChecker < BaseChecker
       attr_reader :model, :enum
 
+      def self.processor
+        Processors::EnumsProcessor
+      end
+
       def initialize(model, enum)
         super()
         @model = model

data/lib/database_consistency/checkers/index_checkers/index_checker.rb

@@ -6,6 +6,10 @@ module DatabaseConsistency
     class IndexChecker < BaseChecker
       attr_reader :model, :index
 
+      def self.processor
+        Processors::IndexesProcessor
+      end
+
       def initialize(model, index)
         super()
         @model = model

data/lib/database_consistency/checkers/index_checkers/redundant_index_checker.rb

@@ -16,7 +16,7 @@ module DatabaseConsistency
       # We skip check when:
       #  - index is unique
       def preconditions
-        !index.unique
+        !index.unique && Helper.btree_index?(index)
       end
 
       # Table of possible statuses
@@ -48,7 +48,7 @@ module DatabaseConsistency
       def covered_by_index
         @covered_by_index ||=
           model.connection.indexes(model.table_name).find do |another_index|
-            next if index.name == another_index.name
+            next if index.name == another_index.name || !Helper.btree_index?(another_index)
 
             clause_equals?(another_index) && include_index_as_prefix?(another_index)
           end

data/lib/database_consistency/checkers/index_checkers/unique_index_checker.rb

@@ -29,10 +29,13 @@ module DatabaseConsistency
       def valid?
         uniqueness_validators = model.validators.select { |validator| validator.kind == :uniqueness }
 
-        uniqueness_validators.any? do |validator|
-          validator.attributes.any? do |attribute|
-            sorted_index_columns == Helper.sorted_uniqueness_validator_columns(attribute, validator, model)
-          end
+        uniqueness_validators.any? { |validator| validator_matches?(validator) }
+      end
+
+      def validator_matches?(validator)
+        validator.attributes.any? do |attribute|
+          sorted_index_columns == Helper.sorted_uniqueness_validator_columns(attribute, validator, model) &&
+            Helper.conditions_match_index?(model, attribute, validator, index.where)
         end
       end
 

data/lib/database_consistency/checkers/model_checkers/model_checker.rb

@@ -6,6 +6,10 @@ module DatabaseConsistency
     class ModelChecker < BaseChecker
       attr_reader :model
 
+      def self.processor
+        Processors::ModelsProcessor
+      end
+
       def initialize(model)
         super()
         @model = model

data/lib/database_consistency/checkers/model_checkers/view_primary_key_checker.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Checkers
+    # This class checks that a model pointing to a view has a primary_key set and that column exists
+    class ViewPrimaryKeyChecker < ModelChecker
+      private
+
+      def preconditions
+        ActiveRecord::VERSION::MAJOR >= 5 &&
+          !model.abstract_class? &&
+          model.connection.view_exists?(model.table_name)
+      end
+
+      # Table of possible statuses
+      # | primary_key set | column exists | status |
+      # | --------------- | ------------- | ------ |
+      # | no              | -             | fail   |
+      # | yes             | no            | fail   |
+      # | yes             | yes           | ok     |
+      def check
+        if model.primary_key.blank?
+          report_template(:fail, error_slug: :view_missing_primary_key)
+        elsif !primary_key_column_exists?
+          report_template(:fail, error_slug: :view_primary_key_column_missing)
+        else
+          report_template(:ok)
+        end
+      end
+
+      def primary_key_column_exists?
+        Array(model.primary_key).all? { |key| model.column_names.include?(key.to_s) }
+      end
+    end
+  end
+end

data/lib/database_consistency/checkers/validator_checkers/missing_unique_index_checker.rb

@@ -28,7 +28,7 @@ module DatabaseConsistency
       # | persisted    | ok     |
       # | missing      | fail   |
       def check
-        if unique_index
+        if unique_index || primary_key_covers_validation?
           report_template(:ok)
         else
           report_template(:fail, error_slug: :missing_unique_index)
@@ -47,9 +47,21 @@ module DatabaseConsistency
       end
 
       def unique_index
-        @unique_index ||= model.connection.indexes(model.table_name).find do |index|
-          index.unique && Helper.extract_index_columns(index.columns).sort == sorted_uniqueness_validator_columns
-        end
+        @unique_index ||= model.connection.indexes(model.table_name).find { |index| index_matches?(index) }
+      end
+
+      def index_matches?(index)
+        index.unique &&
+          Helper.extract_index_columns(index.columns).sort == sorted_uniqueness_validator_columns &&
+          Helper.conditions_match_index?(model, attribute, validator, index.where)
+      end
+
+      def primary_key_covers_validation?
+        primary_key = model.connection.primary_key(model.table_name)
+
+        return false if primary_key.blank?
+
+        sorted_uniqueness_validator_columns == Helper.extract_columns(primary_key).sort
       end
 
       def sorted_uniqueness_validator_columns