database_validations 0.8.5 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51bc2df5e836cbe85e6ec06cc3446652458093b3dba7d7dbd9123e579d67d6ce
-  data.tar.gz: 82b5fdfec69d72f1fecf811f6add8f4e5d606ed2adbd2a6fab1a90125b0e57e2
+  metadata.gz: 7611b039f9baa05f65bee0a18cbfc2cfe2c0ae5e7f69bc01d232b00de5306f92
+  data.tar.gz: 9601fd3196555c0d861b5fb1a3809d25814453db9199fbcc0b115b7976a3012d
 SHA512:
-  metadata.gz: 7a97f163683bc28f3884dbdd5b8d26a4059443199211bd4e5c980e5abdd1ef2b5d37efcc6c8557e0a853fe0fdb1f247f5677b6c0534b7f632bfb25af20e86606
-  data.tar.gz: 556d083c72c34d0b90e381e052999289eb797ba74cd1b938fe5a1a53cdd47511d41472671ea5c10902b6bc02049e1772a2d7b83f0ec0fd1ff43c8298235e4a50
+  metadata.gz: 8a72b136bdd5528cf93dc019c80ecf88b09a9484a68d523e5574e28ee7ffb122122eda7cf3062655015f59637d4dd06de4c3c028c79067fea101b326f15a80e6
+  data.tar.gz: bb9ee57860b06c58853db54583b08acd953f0cdf037d0e11a5faee3b72aa748b022051b3ee21a8fbe3d95f18f7c460c5a1d91e77cbbd2bdf5d4237802b9d8ad4

data/lib/database_validations.rb

@@ -4,18 +4,22 @@ require 'database_validations/version'
 
 require 'database_validations/rails/railtie' if defined?(Rails)
 
-require 'database_validations/validations/uniqueness_handlers'
-require 'database_validations/validations/uniqueness_options'
+require 'database_validations/lib/checkers/db_uniqueness_validator'
+require 'database_validations/lib/checkers/db_presence_validator'
 
-require 'database_validations/validations/belongs_to_presence_validator'
-require 'database_validations/validations/belongs_to_handlers'
-require 'database_validations/validations/belongs_to_options'
+require 'database_validations/lib/validators/db_uniqueness_validator'
+require 'database_validations/lib/validators/db_presence_validator'
 
-require 'database_validations/validations/valid_without_database_validations'
-require 'database_validations/validations/options_storage'
-require 'database_validations/validations/errors'
-require 'database_validations/validations/helpers'
-require 'database_validations/validations/adapters'
+require 'database_validations/lib/storage'
+require 'database_validations/lib/attribute_validator'
+require 'database_validations/lib/key_generator'
+require 'database_validations/lib/uniqueness_key_extractor'
+require 'database_validations/lib/presence_key_extractor'
+require 'database_validations/lib/validations'
+require 'database_validations/lib/errors'
+require 'database_validations/lib/rescuer'
+require 'database_validations/lib/injector'
+require 'database_validations/lib/adapters'
 
 module DatabaseValidations
   extend ActiveSupport::Concern

data/lib/database_validations/lib/adapters.rb

@@ -0,0 +1,20 @@
+require 'database_validations/lib/adapters/base_adapter'
+require 'database_validations/lib/adapters/sqlite_adapter'
+require 'database_validations/lib/adapters/postgresql_adapter'
+require 'database_validations/lib/adapters/mysql_adapter'
+
+module DatabaseValidations
+  module Adapters
+    module_function
+
+    def factory(model)
+      case (database = model.connection_config[:adapter].downcase.to_sym)
+      when SqliteAdapter::ADAPTER then SqliteAdapter
+      when PostgresqlAdapter::ADAPTER then PostgresqlAdapter
+      when MysqlAdapter::ADAPTER then MysqlAdapter
+      else
+        raise Errors::UnknownDatabase, database
+      end
+    end
+  end
+end

data/lib/database_validations/{validations → lib}/adapters/base_adapter.rb

@@ -28,23 +28,7 @@ module DatabaseValidations
       end
 
       def find_foreign_key_by_column(column)
-        model.connection.foreign_key_exists?(model.table_name, column: column)
-      end
-
-      # @return [Symbol]
-      def adapter_name
-        self.class::ADAPTER
-      end
-
-      # @param [Symbol] option_name
-      # @return [Boolean]
-      def support_option?(option_name)
-        supported_options.include?(option_name.to_sym)
-      end
-
-      # @return [Array<Symbol>]
-      def supported_options
-        self.class::SUPPORTED_OPTIONS
+        foreign_keys.find { |foreign_key| foreign_key.column.to_s == column.to_s }
       end
 
       # @return [String]

data/lib/database_validations/lib/adapters/mysql_adapter.rb

@@ -0,0 +1,19 @@
+module DatabaseValidations
+  module Adapters
+    class MysqlAdapter < BaseAdapter
+      ADAPTER = :mysql2
+
+      class << self
+        def unique_index_name(error_message)
+          error_message[/key '([^']+)'/, 1]&.split('.')&.last
+        end
+
+        def unique_error_columns(_error_message); end
+
+        def foreign_key_error_column(error_message)
+          error_message[/FOREIGN KEY \(`([^`]+)`\)/, 1]
+        end
+      end
+    end
+  end
+end

data/lib/database_validations/lib/adapters/postgresql_adapter.rb

@@ -0,0 +1,21 @@
+module DatabaseValidations
+  module Adapters
+    class PostgresqlAdapter < BaseAdapter
+      ADAPTER = :postgresql
+
+      class << self
+        def unique_index_name(error_message)
+          error_message[/unique constraint "([^"]+)"/, 1]
+        end
+
+        def unique_error_columns(error_message)
+          error_message[/Key \((.+)\)=/, 1].split(', ')
+        end
+
+        def foreign_key_error_column(error_message)
+          error_message[/Key \(([^)]+)\)/, 1]
+        end
+      end
+    end
+  end
+end

data/lib/database_validations/lib/adapters/sqlite_adapter.rb

@@ -0,0 +1,19 @@
+module DatabaseValidations
+  module Adapters
+    class SqliteAdapter < BaseAdapter
+      ADAPTER = :sqlite3
+
+      class << self
+        def unique_index_name(_error_message); end
+
+        def unique_error_columns(error_message)
+          error_message.scan(/\w+\.([^,:]+)/).flatten
+        end
+
+        def foreign_key_error_column(error_message)
+          error_message[/\("([^"]+)"\) VALUES/, 1]
+        end
+      end
+    end
+  end
+end

data/lib/database_validations/lib/attribute_validator.rb

@@ -0,0 +1,3 @@
+module DatabaseValidations
+  AttributeValidator = Struct.new(:attribute, :validator)
+end

data/lib/database_validations/lib/checkers/db_presence_validator.rb

@@ -0,0 +1,36 @@
+module DatabaseValidations
+  module Checkers
+    class DbPresenceValidator
+      attr_reader :validator
+
+      # @param [DatabaseValidations::DbPresenceValidator]
+      def self.validate!(validator)
+        new(validator).validate!
+      end
+
+      # @param [DatabaseValidations::DbPresenceValidator]
+      def initialize(validator)
+        @validator = validator
+      end
+
+      def validate!
+        validate_foreign_keys! unless ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
+      end
+
+      private
+
+      def validate_foreign_keys! # rubocop:disable Metrics/AbcSize
+        adapter = Adapters::BaseAdapter.new(validator.klass)
+
+        validator.attributes.each do |attribute|
+          reflection = validator.klass._reflect_on_association(attribute)
+
+          next unless reflection
+          next if adapter.find_foreign_key_by_column(reflection.foreign_key)
+
+          raise Errors::ForeignKeyNotFound.new(reflection.foreign_key, adapter.foreign_keys)
+        end
+      end
+    end
+  end
+end

data/lib/database_validations/lib/checkers/db_uniqueness_validator.rb

@@ -0,0 +1,47 @@
+module DatabaseValidations
+  module Checkers
+    class DbUniquenessValidator
+      attr_reader :validator
+
+      # @param [DatabaseValidations::DbUniquenessValidator]
+      def self.validate!(validator)
+        new(validator).validate!
+      end
+
+      # @param [DatabaseValidations::DbUniquenessValidator]
+      def initialize(validator)
+        @validator = validator
+      end
+
+      def validate!
+        validate_index_usage!
+
+        validate_indexes! unless ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
+      end
+
+      private
+
+      def valid_index?(columns, index)
+        index_columns_size = index.columns.is_a?(Array) ? index.columns.size : (index.columns.count(',') + 1)
+
+        (columns.size == index_columns_size) && (validator.where.nil? == index.where.nil?)
+      end
+
+      def validate_index_usage!
+        return unless validator.index_name.present? && validator.attributes.size > 1
+
+        raise ArgumentError, "When index_name is provided validator can have only one attribute. See #{validator.inspect}"
+      end
+
+      def validate_indexes! # rubocop:disable Metrics/AbcSize
+        adapter = Adapters::BaseAdapter.new(validator.klass)
+
+        validator.attributes.map do |attribute|
+          columns = KeyGenerator.unify_columns(attribute, validator.options[:scope])
+          index = validator.index_name ? adapter.find_index_by_name(validator.index_name.to_s) : adapter.find_index(columns, validator.where) # rubocop:disable Metrics/LineLength
+          raise Errors::IndexNotFound.new(columns, validator.where, validator.index_name, adapter.indexes, adapter.table_name) unless index && valid_index?(columns, index) # rubocop:disable Metrics/LineLength
+        end
+      end
+    end
+  end
+end

data/lib/database_validations/{validations → lib}/errors.rb

@@ -41,17 +41,6 @@ module DatabaseValidations
       end
     end
 
-    class OptionIsNotSupported < Base
-      attr_reader :option, :database, :supported_options
-
-      def initialize(option, database, supported_options)
-        @option = option
-        @database = database
-        @supported_options = supported_options
-        super "Option #{self.option} is not supported for #{self.database}. Supported options are: #{self.supported_options}"
-      end
-    end
-
     class ForeignKeyNotFound < Base
       attr_reader :column, :foreign_keys
 
@@ -59,7 +48,7 @@ module DatabaseValidations
         @column = column
         @foreign_keys = foreign_keys
 
-        super "No foreign key found with column: \"#{column}\". Founded foreign keys are: #{foreign_keys}. " + env_message
+        super "No foreign key found with column: \"#{column}\". Found foreign keys are: #{foreign_keys}. " + env_message
       end
     end
 

data/lib/database_validations/lib/injector.rb

@@ -0,0 +1,13 @@
+module DatabaseValidations
+  module Injector
+    module_function
+
+    # @param [ActiveRecord::Base] model
+    def inject(model)
+      return if model.method_defined?(:valid_without_database_validations?)
+
+      model.__send__(:alias_method, :valid_without_database_validations?, :valid?)
+      model.include(DatabaseValidations::Validations)
+    end
+  end
+end

data/lib/database_validations/lib/key_generator.rb

@@ -0,0 +1,32 @@
+module DatabaseValidations
+  module KeyGenerator
+    module_function
+
+    # @param [String] index_name
+    #
+    # @return [String]
+    def for_unique_index(index_name)
+      generate_key(:unique_index, index_name)
+    end
+
+    # @return [String]
+    def for_db_uniqueness(*columns)
+      generate_key(:db_uniqueness, columns)
+    end
+
+    # @return [String]
+    def for_db_presence(column)
+      generate_key(:db_presence, column)
+    end
+
+    # @return [String]
+    def generate_key(type, *args)
+      [type, *unify_columns(args)].join('__')
+    end
+
+    # @return [String]
+    def unify_columns(*args)
+      args.flatten.compact.map(&:to_s).sort
+    end
+  end
+end

data/lib/database_validations/lib/presence_key_extractor.rb

@@ -0,0 +1,18 @@
+module DatabaseValidations
+  module PresenceKeyExtractor
+    module_function
+
+    # @param [DatabaseValidations::DbPresenceValidator]
+    #
+    # @return [Hash]
+    def attribute_by_key(validator)
+      validator.attributes.map do |attribute|
+        reflection = validator.klass._reflect_on_association(attribute)
+
+        key = reflection ? reflection.foreign_key : attribute
+
+        [KeyGenerator.for_db_presence(key), attribute]
+      end.to_h
+    end
+  end
+end

data/lib/database_validations/lib/rescuer.rb

@@ -0,0 +1,36 @@
+module DatabaseValidations
+  module Rescuer
+    module_function
+
+    def handled?(instance, error)
+      Storage.prepare(instance.class) unless Storage.prepared?(instance.class)
+
+      case error
+      when ActiveRecord::RecordNotUnique
+        process(instance, error, for_unique_index: :unique_index_name, for_db_uniqueness: :unique_error_columns)
+      when ActiveRecord::InvalidForeignKey
+        process(instance, error, for_db_presence: :foreign_key_error_column)
+      else false
+      end
+    end
+
+    def process(instance, error, key_types)
+      adapter = Adapters.factory(instance.class)
+
+      keys = key_types.map do |key_generator, error_processor|
+        KeyGenerator.public_send(key_generator, adapter.public_send(error_processor, error.message))
+      end
+
+      keys.each do |key|
+        attribute_validator = instance._db_validators[key]
+
+        if attribute_validator
+          attribute_validator.validator.apply_error(instance, attribute_validator.attribute)
+          return true
+        end
+      end
+
+      false
+    end
+  end
+end

data/lib/database_validations/lib/storage.rb

@@ -0,0 +1,28 @@
+module DatabaseValidations
+  module Storage
+    module_function
+
+    def prepare(model)
+      model.class_attribute :_db_validators, instance_writer: false
+      model._db_validators = {}
+
+      model.validators.each do |validator|
+        case validator
+        when DbUniquenessValidator then process(validator, UniquenessKeyExtractor, model)
+        when DbPresenceValidator then process(validator, PresenceKeyExtractor, model)
+        else next
+        end
+      end
+    end
+
+    def process(validator, extractor, model)
+      extractor.attribute_by_key(validator).each do |key, attribute|
+        model._db_validators[key] = AttributeValidator.new(attribute, validator)
+      end
+    end
+
+    def prepared?(model)
+      model.respond_to?(:_db_validators)
+    end
+  end
+end

data/lib/database_validations/lib/uniqueness_key_extractor.rb

@@ -0,0 +1,38 @@
+module DatabaseValidations
+  module UniquenessKeyExtractor
+    module_function
+
+    # @param [DatabaseValidations::DbUniquenessValidator]
+    #
+    # @return [Hash]
+    def attribute_by_columns_keys(validator)
+      validator.attributes.map do |attribute|
+        [KeyGenerator.for_db_uniqueness(attribute, Array.wrap(validator.options[:scope])), attribute]
+      end.to_h
+    end
+
+    # @param [DatabaseValidations::DbUniquenessValidator]
+    #
+    # @return [Hash]
+    def attribute_by_indexes_keys(validator) # rubocop:disable Metrics/AbcSize
+      adapter = Adapters::BaseAdapter.new(validator.klass)
+
+      if validator.index_name
+        [[KeyGenerator.for_unique_index(validator.index_name), validator.attributes[0]]].to_h
+      else
+        validator.attributes.map do |attribute|
+          columns = KeyGenerator.unify_columns(attribute, validator.options[:scope])
+          index = adapter.find_index(columns, validator.where)
+          [KeyGenerator.for_unique_index(index.name), attribute]
+        end.to_h
+      end
+    end
+
+    # @param [DatabaseValidations::DbUniquenessValidator]
+    #
+    # @return [Hash]
+    def attribute_by_key(validator)
+      attribute_by_columns_keys(validator).merge(attribute_by_indexes_keys(validator))
+    end
+  end
+end