activerecord 7.0.8 → 7.1.3.4

data/lib/active_record/database_configurations/database_config.rb

@@ -3,13 +3,11 @@
 module ActiveRecord
   class DatabaseConfigurations
     # ActiveRecord::Base.configurations will return either a HashConfig or
-    # UrlConfig respectively. It will never return a DatabaseConfig object,
+    # UrlConfig respectively. It will never return a +DatabaseConfig+ object,
     # as this is the parent class for the types of database configuration objects.
     class DatabaseConfig # :nodoc:
       attr_reader :env_name, :name
 
-      attr_accessor :owner_name
-
       def initialize(env_name, name)
         @env_name = env_name
         @name = name
@@ -19,6 +17,10 @@ module ActiveRecord
         "#{adapter}_connection"
       end
 
+      def adapter_class_method
+        "#{adapter}_adapter_class"
+      end
+
       def host
         raise NotImplementedError
       end
@@ -51,6 +53,10 @@ module ActiveRecord
         raise NotImplementedError
       end
 
+      def query_cache
+        raise NotImplementedError
+      end
+
       def checkout_timeout
         raise NotImplementedError
       end

data/lib/active_record/database_configurations/hash_config.rb

@@ -2,7 +2,9 @@
 
 module ActiveRecord
   class DatabaseConfigurations
-    # A HashConfig object is created for each database configuration entry that
+    # = Active Record Database Hash Config
+    #
+    # A +HashConfig+ object is created for each database configuration entry that
     # is created from a hash.
     #
     # A hash config:
@@ -14,19 +16,23 @@ module ActiveRecord
     #   #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
     #     @env_name="development", @name="primary", @config={database: "db_name"}>
     #
-    # ==== Options
-    #
-    # * <tt>:env_name</tt> - The Rails environment, i.e. "development".
-    # * <tt>:name</tt> - The db config name. In a standard two-tier
-    #   database configuration this will default to "primary". In a multiple
-    #   database three-tier database configuration this corresponds to the name
-    #   used in the second tier, for example "primary_readonly".
-    # * <tt>:config</tt> - The config hash. This is the hash that contains the
-    #   database adapter, name, and other important information for database
-    #   connections.
+    # See ActiveRecord::DatabaseConfigurations for more info.
     class HashConfig < DatabaseConfig
       attr_reader :configuration_hash
 
+
+      # Initialize a new +HashConfig+ object
+      #
+      # ==== Options
+      #
+      # * <tt>:env_name</tt> - The \Rails environment, i.e. "development".
+      # * <tt>:name</tt> - The db config name. In a standard two-tier
+      #   database configuration this will default to "primary". In a multiple
+      #   database three-tier database configuration this corresponds to the name
+      #   used in the second tier, for example "primary_readonly".
+      # * <tt>:config</tt> - The config hash. This is the hash that contains the
+      #   database adapter, name, and other important information for database
+      #   connections.
       def initialize(env_name, name, configuration_hash)
         super(env_name, name)
         @configuration_hash = configuration_hash.symbolize_keys.freeze
@@ -74,6 +80,10 @@ module ActiveRecord
         (configuration_hash[:max_threads] || pool).to_i
       end
 
+      def query_cache
+        configuration_hash[:query_cache]
+      end
+
       def max_queue
         max_threads * 4
       end
@@ -122,7 +132,7 @@ module ActiveRecord
       # If +configuration_hash[:schema_dump]+ is set to +false+ or +nil+
       # the schema will not be dumped.
       #
-      # If the config option is set that will be used. Otherwise Rails
+      # If the config option is set that will be used. Otherwise \Rails
       # will generate the filename from the database config name.
       def schema_dump(format = ActiveRecord.schema_format)
         if configuration_hash.key?(:schema_dump)

data/lib/active_record/database_configurations/url_config.rb

@@ -2,7 +2,9 @@
 
 module ActiveRecord
   class DatabaseConfigurations
-    # A UrlConfig object is created for each database configuration
+    # = Active Record Database Url Config
+    #
+    # A +UrlConfig+ object is created for each database configuration
     # entry that is created from a URL. This can either be a URL string
     # or a hash with a URL in place of the config hash.
     #
@@ -17,20 +19,24 @@ module ActiveRecord
     #     @config={adapter: "postgresql", database: "foo", host: "localhost"},
     #     @url="postgres://localhost/foo">
     #
-    # ==== Options
+    # See ActiveRecord::DatabaseConfigurations for more info.
     #
-    # * <tt>:env_name</tt> - The Rails environment, i.e. "development".
-    # * <tt>:name</tt> - The db config name. In a standard two-tier
-    #   database configuration this will default to "primary". In a multiple
-    #   database three-tier database configuration this corresponds to the name
-    #   used in the second tier, for example "primary_readonly".
-    # * <tt>:url</tt> - The database URL.
-    # * <tt>:config</tt> - The config hash. This is the hash that contains the
-    #   database adapter, name, and other important information for database
-    #   connections.
     class UrlConfig < HashConfig
       attr_reader :url
 
+      # Initialize a new +UrlConfig+ object
+      #
+      # ==== Options
+      #
+      # * <tt>:env_name</tt> - The \Rails environment, i.e. "development".
+      # * <tt>:name</tt> - The db config name. In a standard two-tier
+      #   database configuration this will default to "primary". In a multiple
+      #   database three-tier database configuration this corresponds to the name
+      #   used in the second tier, for example "primary_readonly".
+      # * <tt>:url</tt> - The database URL.
+      # * <tt>:config</tt> - The config hash. This is the hash that contains the
+      #   database adapter, name, and other important information for database
+      #   connections.
       def initialize(env_name, name, url, configuration_hash = {})
         super(env_name, name, configuration_hash)
 

data/lib/active_record/database_configurations.rb

@@ -7,15 +7,69 @@ require "active_record/database_configurations/url_config"
 require "active_record/database_configurations/connection_url_resolver"
 
 module ActiveRecord
-  # ActiveRecord::DatabaseConfigurations returns an array of DatabaseConfig
-  # objects (either a HashConfig or UrlConfig) that are constructed from the
-  # application's database configuration hash or URL string.
+  # = Active Record Database Configurations
+  #
+  # +ActiveRecord::DatabaseConfigurations+ returns an array of +DatabaseConfig+
+  # objects that are constructed from the application's database
+  # configuration hash or URL string.
+  #
+  # The array of +DatabaseConfig+ objects in an application default to either a
+  # HashConfig or UrlConfig. You can retrieve your application's config by using
+  # ActiveRecord::Base.configurations.
+  #
+  # If you register a custom handler, objects will be created according to the
+  # conditions of the handler. See ::register_db_config_handler for more on
+  # registering custom handlers.
   class DatabaseConfigurations
     class InvalidConfigurationError < StandardError; end
 
     attr_reader :configurations
     delegate :any?, to: :configurations
 
+    singleton_class.attr_accessor :db_config_handlers # :nodoc:
+    self.db_config_handlers = [] # :nodoc:
+
+    # Allows an application to register a custom handler for database configuration
+    # objects. This is useful for creating a custom handler that responds to
+    # methods your application needs but Active Record doesn't implement. For
+    # example if you are using Vitess, you may want your Vitess configurations
+    # to respond to `sharded?`. To implement this define the following in an
+    # initializer:
+    #
+    #   ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config|
+    #     next unless config.key?(:vitess)
+    #     VitessConfig.new(env_name, name, config)
+    #   end
+    #
+    # Note: applications must handle the condition in which custom config should be
+    # created in your handler registration otherwise all objects will use the custom
+    # handler.
+    #
+    # Then define your +VitessConfig+ to respond to the methods your application
+    # needs. It is recommended that you inherit from one of the existing
+    # database config classes to avoid having to reimplement all methods. Custom
+    # config handlers should only implement methods Active Record does not.
+    #
+    #   class VitessConfig < ActiveRecord::DatabaseConfigurations::UrlConfig
+    #     def sharded?
+    #       configuration_hash.fetch("sharded", false)
+    #     end
+    #   end
+    #
+    # For configs that have a +:vitess+ key, a +VitessConfig+ object will be
+    # created instead of a +UrlConfig+.
+    def self.register_db_config_handler(&block)
+      db_config_handlers << block
+    end
+
+    register_db_config_handler do |env_name, name, url, config|
+      if url
+        UrlConfig.new(env_name, name, url, config)
+      else
+        HashConfig.new(env_name, name, config)
+      end
+    end
+
     def initialize(configurations = {})
       @configurations = build_configs(configurations)
     end
@@ -23,8 +77,8 @@ module ActiveRecord
     # Collects the configs for the environment and optionally the specification
     # name passed in. To include replica configurations pass <tt>include_hidden: true</tt>.
     #
-    # If a name is provided a single DatabaseConfig object will be
-    # returned, otherwise an array of DatabaseConfig objects will be
+    # If a name is provided a single +DatabaseConfig+ object will be
+    # returned, otherwise an array of +DatabaseConfig+ objects will be
     # returned that corresponds with the environment and type requested.
     #
     # ==== Options
@@ -34,20 +88,14 @@ module ActiveRecord
     # * <tt>name:</tt> The db config name (i.e. primary, animals, etc.). Defaults
     #   to +nil+. If no +env_name+ is specified the config for the default env and the
     #   passed +name+ will be returned.
-    # * <tt>include_replicas:</tt> Deprecated. Determines whether to include replicas in
-    #   the returned list. Most of the time we're only iterating over the write
-    #   connection (i.e. migrations don't need to run for the write and read connection).
-    #   Defaults to +false+.
+    # * <tt>config_key:</tt> Selects configs that contain a particular key in the configuration
+    #   hash. Useful for selecting configs that use a custom db config handler or finding
+    #   configs with hashes that contain a particular key.
     # * <tt>include_hidden:</tt> Determines whether to include replicas and configurations
-    #   hidden by +database_tasks: false+ in the returned list. Most of the time we're only
+    #   hidden by <tt>database_tasks: false</tt> in the returned list. Most of the time we're only
     #   iterating over the primary connections (i.e. migrations don't need to run for the
     #   write and read connection). Defaults to +false+.
-    def configs_for(env_name: nil, name: nil, include_replicas: false, include_hidden: false)
-      if include_replicas
-        include_hidden = include_replicas
-        ActiveSupport::Deprecation.warn("The kwarg `include_replicas` is deprecated in favor of `include_hidden`. When `include_hidden` is passed, configurations with `replica: true` or `database_tasks: false` will be returned. `include_replicas` will be removed in Rails 7.1.")
-      end
-
+    def configs_for(env_name: nil, name: nil, config_key: nil, include_hidden: false)
       env_name ||= default_env if name
       configs = env_with_configs(env_name)
 
@@ -57,6 +105,12 @@ module ActiveRecord
         end
       end
 
+      if config_key
+        configs = configs.select do |db_config|
+          db_config.configuration_hash.key?(config_key)
+        end
+      end
+
       if name
         configs.find do |db_config|
           db_config.name == name
@@ -66,17 +120,17 @@ module ActiveRecord
       end
     end
 
-    # Returns a single DatabaseConfig object based on the requested environment.
+    # Returns a single +DatabaseConfig+ object based on the requested environment.
     #
     # If the application has multiple databases +find_db_config+ will return
-    # the first DatabaseConfig for the environment.
+    # the first +DatabaseConfig+ for the environment.
     def find_db_config(env)
-      configurations
-        .sort_by.with_index { |db_config, i| db_config.for_current_env? ? [0, i] : [1, i] }
-        .find do |db_config|
-          db_config.env_name == env.to_s ||
-            (db_config.for_current_env? && db_config.name == env.to_s)
-        end
+      env = env.to_s
+      configurations.find do |db_config|
+        db_config.for_current_env? && (db_config.env_name == env || db_config.name == env)
+      end || configurations.find do |db_config|
+        db_config.env_name == env
+      end
     end
 
     # A primary configuration is one that is named primary or if there is
@@ -93,8 +147,6 @@ module ActiveRecord
     end
 
     # Checks if the application's configurations are empty.
-    #
-    # Aliased to blank?
     def empty?
       configurations.empty?
     end
@@ -219,15 +271,16 @@ module ActiveRecord
       end
 
       def build_db_config_from_hash(env_name, name, config)
-        if config.has_key?(:url)
-          url = config[:url]
-          config_without_url = config.dup
-          config_without_url.delete :url
+        url = config[:url]
+        config_without_url = config.dup
+        config_without_url.delete :url
 
-          UrlConfig.new(env_name, name, url, config_without_url)
-        else
-          HashConfig.new(env_name, name, config)
+        DatabaseConfigurations.db_config_handlers.reverse_each do |handler|
+          config = handler.call(env_name, name, url, config_without_url)
+          return config if config
         end
+
+        nil
       end
 
       def merge_db_environment_variables(current_env, configs)

data/lib/active_record/delegated_type.rb

@@ -3,7 +3,7 @@
 require "active_support/core_ext/string/inquiry"
 
 module ActiveRecord
-  # == Delegated types
+  # = Delegated types
   #
   # Class hierarchies can map to relational database tables in many ways. Active Record, for example, offers
   # purely abstract classes, where the superclass doesn't persist any attributes, and single-table inheritance,
@@ -138,7 +138,7 @@ module ActiveRecord
   #
   # Now you can list a bunch of entries, call <tt>Entry#title</tt>, and polymorphism will provide you with the answer.
   #
-  # == Nested Attributes
+  # == Nested \Attributes
   #
   # Enabling nested attributes on a delegated_type association allows you to
   # create the entry and message in one go:
@@ -192,6 +192,11 @@ module ActiveRecord
     #   +role+ with an "_id" suffix. So a class that defines a
     #   <tt>delegated_type :entryable, types: %w[ Message Comment ]</tt> association will use "entryable_id" as
     #   the default <tt>:foreign_key</tt>.
+    # [:foreign_type]
+    #   Specify the column used to store the associated object's type. By default this is inferred to be the passed
+    #   +role+ with a "_type" suffix. A class that defines a
+    #   <tt>delegated_type :entryable, types: %w[ Message Comment ]</tt> association will use "entryable_type" as
+    #   the default <tt>:foreign_type</tt>.
     # [:primary_key]
     #   Specify the method that returns the primary key of associated object used for the convenience methods.
     #   By default this is +id+.
@@ -211,11 +216,11 @@ module ActiveRecord
     private
       def define_delegated_type_methods(role, types:, options:)
         primary_key = options[:primary_key] || "id"
-        role_type = "#{role}_type"
+        role_type = options[:foreign_type] || "#{role}_type"
         role_id   = options[:foreign_key] || "#{role}_id"
 
         define_method "#{role}_class" do
-          public_send("#{role}_type").constantize
+          public_send(role_type).constantize
         end
 
         define_method "#{role}_name" do

data/lib/active_record/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/active_record/destroy_association_async_job.rb

@@ -4,6 +4,8 @@ module ActiveRecord
   class DestroyAssociationAsyncError < StandardError
   end
 
+  # = Active Record Destroy Association Async Job
+  #
   # Job to destroy the records associated with a destroyed record in background.
   class DestroyAssociationAsyncJob < ActiveJob::Base
     queue_as { ActiveRecord.queues[:destroy] }

data/lib/active_record/encryption/auto_filtered_parameters.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    class AutoFilteredParameters
+      def initialize(app)
+        @app = app
+        @attributes_by_class = Concurrent::Map.new
+        @collecting = true
+
+        install_collecting_hook
+      end
+
+      def enable
+        apply_collected_attributes
+        @collecting = false
+      end
+
+      private
+        attr_reader :app
+
+        def install_collecting_hook
+          ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, attribute|
+            attribute_was_declared(klass, attribute)
+          end
+        end
+
+        def attribute_was_declared(klass, attribute)
+          if collecting?
+            collect_for_later(klass, attribute)
+          else
+            apply_filter(klass, attribute)
+          end
+        end
+
+        def apply_collected_attributes
+          @attributes_by_class.each do |klass, attributes|
+            attributes.each do |attribute|
+              apply_filter(klass, attribute)
+            end
+          end
+        end
+
+        def collecting?
+          @collecting
+        end
+
+        def collect_for_later(klass, attribute)
+          @attributes_by_class[klass] ||= Concurrent::Array.new
+          @attributes_by_class[klass] << attribute
+        end
+
+        def apply_filter(klass, attribute)
+          filter = [("#{klass.model_name.element}" if klass.name), attribute.to_s].compact.join(".")
+          unless excluded_from_filter_parameters?(filter)
+            app.config.filter_parameters << filter unless app.config.filter_parameters.include?(filter)
+            klass.filter_attributes += [ attribute ]
+          end
+        end
+
+        def excluded_from_filter_parameters?(filter_parameter)
+          ActiveRecord::Encryption.config.excluded_from_filter_parameters.find { |excluded_filter| excluded_filter.to_s == filter_parameter }
+        end
+    end
+  end
+end

data/lib/active_record/encryption/cipher/aes256_gcm.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "openssl"
-require "base64"
 
 module ActiveRecord
   module Encryption
@@ -80,6 +79,10 @@ module ActiveRecord
           raise ActiveRecord::Encryption::Errors::Decryption
         end
 
+        def inspect # :nodoc:
+          "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+        end
+
         private
           def generate_iv(cipher, clear_text)
             if @deterministic

data/lib/active_record/encryption/config.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "openssl"
+
 module ActiveRecord
   module Encryption
     # Container of configuration options
     class Config
-      attr_accessor :primary_key, :deterministic_key, :store_key_references, :key_derivation_salt,
+      attr_accessor :primary_key, :deterministic_key, :store_key_references, :key_derivation_salt, :hash_digest_class,
                     :support_unencrypted_data, :encrypt_fixtures, :validate_column_size, :add_to_filter_parameters,
                     :excluded_from_filter_parameters, :extend_queries, :previous_schemes, :forced_encoding_for_deterministic_encryption
 
@@ -21,6 +23,27 @@ module ActiveRecord
         end
       end
 
+      def support_sha1_for_non_deterministic_encryption=(value)
+        if value && has_primary_key?
+          sha1_key_generator = ActiveRecord::Encryption::KeyGenerator.new(hash_digest_class: OpenSSL::Digest::SHA1)
+          sha1_key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new(primary_key, key_generator: sha1_key_generator)
+          add_previous_scheme key_provider: sha1_key_provider
+        end
+      end
+
+      %w(key_derivation_salt primary_key deterministic_key).each do |key|
+        silence_redefinition_of_method "has_#{key}?"
+        define_method("has_#{key}?") do
+          instance_variable_get(:"@#{key}").presence
+        end
+
+        silence_redefinition_of_method key
+        define_method(key) do
+          public_send("has_#{key}?") or
+            raise Errors::Configuration, "Missing Active Record encryption credential: active_record_encryption.#{key}"
+        end
+      end
+
       private
         def set_defaults
           self.store_key_references = false
@@ -31,6 +54,7 @@ module ActiveRecord
           self.excluded_from_filter_parameters = []
           self.previous_schemes = []
           self.forced_encoding_for_deterministic_encryption = Encoding::UTF_8
+          self.hash_digest_class = OpenSSL::Digest::SHA1
 
           # TODO: Setting to false for now as the implementation is a bit experimental
           self.extend_queries = false

data/lib/active_record/encryption/configurable.rb

@@ -17,24 +17,29 @@ module ActiveRecord
           delegate name, to: :context
         end
 
-        def configure(primary_key:, deterministic_key:, key_derivation_salt:, **properties) # :nodoc:
+        def configure(primary_key: nil, deterministic_key: nil, key_derivation_salt: nil, **properties) # :nodoc:
           config.primary_key = primary_key
           config.deterministic_key = deterministic_key
           config.key_derivation_salt = key_derivation_salt
 
-          context.key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new(primary_key)
+          # Set the default for this property here instead of in +Config#set_defaults+ as this needs
+          # to happen *after* the keys have been set.
+          properties[:support_sha1_for_non_deterministic_encryption] = true if properties[:support_sha1_for_non_deterministic_encryption].nil?
 
           properties.each do |name, value|
-            [:context, :config].each do |configurable_object_name|
-              configurable_object = ActiveRecord::Encryption.send(configurable_object_name)
-              configurable_object.send "#{name}=", value if configurable_object.respond_to?("#{name}=")
-            end
+            ActiveRecord::Encryption.config.send "#{name}=", value if ActiveRecord::Encryption.config.respond_to?("#{name}=")
+          end
+
+          ActiveRecord::Encryption.reset_default_context
+
+          properties.each do |name, value|
+            ActiveRecord::Encryption.context.send "#{name}=", value if ActiveRecord::Encryption.context.respond_to?("#{name}=")
           end
         end
 
         # Register callback to be invoked when an encrypted attribute is declared.
         #
-        # === Example:
+        # === Example
         #
         #   ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, attribute_name|
         #     ...
@@ -49,18 +54,6 @@ module ActiveRecord
             block.call(klass, name)
           end
         end
-
-        def install_auto_filtered_parameters_hook(application) # :nodoc:
-          ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, encrypted_attribute_name|
-            filter_parameter = [("#{klass.model_name.element}" if klass.name), encrypted_attribute_name.to_s].compact.join(".")
-            application.config.filter_parameters << filter_parameter unless excluded_from_filter_parameters?(filter_parameter)
-          end
-        end
-
-        private
-          def excluded_from_filter_parameters?(filter_parameter)
-            ActiveRecord::Encryption.config.excluded_from_filter_parameters.find { |excluded_filter| excluded_filter.to_s == filter_parameter }
-          end
       end
     end
   end

data/lib/active_record/encryption/context.rb

@@ -12,9 +12,7 @@ module ActiveRecord
     class Context
       PROPERTIES = %i[ key_provider key_generator cipher message_serializer encryptor frozen_encryption ]
 
-      PROPERTIES.each do |name|
-        attr_accessor name
-      end
+      attr_accessor(*PROPERTIES)
 
       def initialize
         set_defaults
@@ -22,6 +20,11 @@ module ActiveRecord
 
       alias frozen_encryption? frozen_encryption
 
+      silence_redefinition_of_method :key_provider
+      def key_provider
+        @key_provider ||= build_default_key_provider
+      end
+
       private
         def set_defaults
           self.frozen_encryption = false
@@ -30,6 +33,10 @@ module ActiveRecord
           self.encryptor = ActiveRecord::Encryption::Encryptor.new
           self.message_serializer = ActiveRecord::Encryption::MessageSerializer.new
         end
+
+        def build_default_key_provider
+          ActiveRecord::Encryption::DerivedSecretKeyProvider.new(ActiveRecord::Encryption.config.primary_key)
+        end
     end
   end
 end

data/lib/active_record/encryption/contexts.rb

@@ -14,7 +14,7 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        mattr_reader :default_context, default: Context.new
+        mattr_accessor :default_context, default: Context.new
         thread_mattr_accessor :custom_contexts
       end
 
@@ -66,6 +66,10 @@ module ActiveRecord
         def current_custom_context
           self.custom_contexts&.last
         end
+
+        def reset_default_context
+          self.default_context = Context.new
+        end
       end
     end
   end

data/lib/active_record/encryption/derived_secret_key_provider.rb

@@ -4,9 +4,15 @@ module ActiveRecord
   module Encryption
     # A KeyProvider that derives keys from passwords.
     class DerivedSecretKeyProvider < KeyProvider
-      def initialize(passwords)
-        super(Array(passwords).collect { |password| Key.derive_from(password) })
+      def initialize(passwords, key_generator: ActiveRecord::Encryption.key_generator)
+        super(Array(passwords).collect { |password| derive_key_from(password, using: key_generator) })
       end
+
+      private
+        def derive_key_from(password, using: key_generator)
+          secret = using.derive_key_from(password)
+          ActiveRecord::Encryption::Key.new(secret)
+        end
     end
   end
 end