activerecord 6.1.7.8 → 7.0.8.4

data/lib/active_record/encryption/properties.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # This is a wrapper for a hash of encryption properties. It is used by
+    # +Key+ (public tags) and +Message+ (headers).
+    #
+    # Since properties are serialized in messages, it is important for storage
+    # efficiency to keep their keys as short as possible. It defines accessors
+    # for common properties that will keep these keys very short while exposing
+    # a readable name.
+    #
+    #   message.headers.encrypted_data_key # instead of message.headers[:k]
+    #
+    # See +Properties::DEFAULT_PROPERTIES+, Key, Message
+    class Properties
+      ALLOWED_VALUE_CLASSES = [String, ActiveRecord::Encryption::Message, Numeric, TrueClass, FalseClass, Symbol, NilClass]
+
+      delegate_missing_to :data
+      delegate :==, to: :data
+
+      # For each entry it generates an accessor exposing the full name
+      DEFAULT_PROPERTIES = {
+        encrypted_data_key: "k",
+        encrypted_data_key_id: "i",
+        compressed: "c",
+        iv: "iv",
+        auth_tag: "at",
+        encoding: "e"
+      }
+
+      DEFAULT_PROPERTIES.each do |name, key|
+        define_method name do
+          self[key.to_sym]
+        end
+
+        define_method "#{name}=" do |value|
+          self[key.to_sym] = value
+        end
+      end
+
+      def initialize(initial_properties = {})
+        @data = {}
+        add(initial_properties)
+      end
+
+      # Set a value for a given key
+      #
+      # It will raise an +EncryptedContentIntegrity+ if the value exists
+      def []=(key, value)
+        raise Errors::EncryptedContentIntegrity, "Properties can't be overridden: #{key}" if key?(key)
+        validate_value_type(value)
+        data[key] = value
+      end
+
+      def validate_value_type(value)
+        unless ALLOWED_VALUE_CLASSES.find { |klass| value.is_a?(klass) }
+          raise ActiveRecord::Encryption::Errors::ForbiddenClass, "Can't store a #{value.class}, only properties of type #{ALLOWED_VALUE_CLASSES.inspect} are allowed"
+        end
+      end
+
+      def add(other_properties)
+        other_properties.each do |key, value|
+          self[key.to_sym] = value
+        end
+      end
+
+      def to_h
+        data
+      end
+
+      private
+        attr_reader :data
+    end
+  end
+end

data/lib/active_record/encryption/read_only_null_encryptor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A +NullEncryptor+ that will raise an error when trying to encrypt data
+    #
+    # This is useful when you want to reveal ciphertexts for debugging purposes
+    # and you want to make sure you won't overwrite any encryptable attribute with
+    # the wrong content.
+    class ReadOnlyNullEncryptor
+      def encrypt(clean_text, key_provider: nil, cipher_options: {})
+        raise Errors::Encryption, "This encryptor is read-only"
+      end
+
+      def decrypt(encrypted_text, key_provider: nil, cipher_options: {})
+        encrypted_text
+      end
+
+      def encrypted?(text)
+        false
+      end
+    end
+  end
+end

data/lib/active_record/encryption/scheme.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A container of attribute encryption options.
+    #
+    # It validates and serves attribute encryption options.
+    #
+    # See EncryptedAttributeType, Context
+    class Scheme
+      attr_accessor :previous_schemes
+
+      def initialize(key_provider: nil, key: nil, deterministic: nil, downcase: nil, ignore_case: nil,
+                     previous_schemes: nil, **context_properties)
+        # Initializing all attributes to +nil+ as we want to allow a "not set" semantics so that we
+        # can merge schemes without overriding values with defaults. See +#merge+
+
+        @key_provider_param = key_provider
+        @key = key
+        @deterministic = deterministic
+        @downcase = downcase || ignore_case
+        @ignore_case = ignore_case
+        @previous_schemes_param = previous_schemes
+        @previous_schemes = Array.wrap(previous_schemes)
+        @context_properties = context_properties
+
+        validate_config!
+      end
+
+      def ignore_case?
+        @ignore_case
+      end
+
+      def downcase?
+        @downcase
+      end
+
+      def deterministic?
+        @deterministic
+      end
+
+      def fixed?
+        # by default deterministic encryption is fixed
+        @fixed ||= @deterministic && (!@deterministic.is_a?(Hash) || @deterministic[:fixed])
+      end
+
+      def key_provider
+        @key_provider ||= begin
+          validate_keys!
+          @key_provider_param || build_key_provider
+        end
+      end
+
+      def merge(other_scheme)
+        self.class.new(**to_h.merge(other_scheme.to_h))
+      end
+
+      def to_h
+        { key_provider: @key_provider_param, key: @key, deterministic: @deterministic, downcase: @downcase, ignore_case: @ignore_case,
+          previous_schemes: @previous_schemes_param, **@context_properties }.compact
+      end
+
+      def with_context(&block)
+        if @context_properties.present?
+          ActiveRecord::Encryption.with_encryption_context(**@context_properties, &block)
+        else
+          block.call
+        end
+      end
+
+      private
+        def validate_config!
+          raise Errors::Configuration, "ignore_case: can only be used with deterministic encryption" if @ignore_case && !@deterministic
+          raise Errors::Configuration, "key_provider: and key: can't be used simultaneously" if @key_provider_param && @key
+        end
+
+        def validate_keys!
+          validate_credential :key_derivation_salt
+          validate_credential :primary_key, "needs to be configured to use non-deterministic encryption" unless @deterministic
+          validate_credential :deterministic_key, "needs to be configured to use deterministic encryption" if @deterministic
+        end
+
+        def validate_credential(key, error_message = "is not configured")
+          unless ActiveRecord::Encryption.config.public_send(key).present?
+            raise Errors::Configuration, "#{key} #{error_message}. Please configure it via credential "\
+              "active_record_encryption.#{key} or by setting config.active_record.encryption.#{key}"
+          end
+        end
+
+        def build_key_provider
+          return DerivedSecretKeyProvider.new(@key) if @key.present?
+
+          if @deterministic && (deterministic_key = ActiveRecord::Encryption.config.deterministic_key)
+            DeterministicKeyProvider.new(deterministic_key)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/encryption.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+require "active_support/core_ext/array"
+
+module ActiveRecord
+  module Encryption
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Cipher
+      autoload :Config
+      autoload :Configurable
+      autoload :Context
+      autoload :Contexts
+      autoload :DerivedSecretKeyProvider
+      autoload :EncryptableRecord
+      autoload :EncryptedAttributeType
+      autoload :EncryptedFixtures
+      autoload :EncryptingOnlyEncryptor
+      autoload :DeterministicKeyProvider
+      autoload :Encryptor
+      autoload :EnvelopeEncryptionKeyProvider
+      autoload :Errors
+      autoload :ExtendedDeterministicQueries
+      autoload :ExtendedDeterministicUniquenessValidator
+      autoload :Key
+      autoload :KeyGenerator
+      autoload :KeyProvider
+      autoload :Message
+      autoload :MessageSerializer
+      autoload :NullEncryptor
+      autoload :Properties
+      autoload :ReadOnlyNullEncryptor
+      autoload :Scheme
+    end
+
+    class Cipher
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Aes256Gcm
+      end
+    end
+
+    include Configurable
+    include Contexts
+
+    def self.eager_load!
+      super
+
+      Cipher.eager_load!
+    end
+  end
+end

data/lib/active_record/enum.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/hash/slice"
 require "active_support/core_ext/object/deep_dup"
 
 module ActiveRecord
@@ -7,7 +8,7 @@ module ActiveRecord
   # but can be queried by name. Example:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [ :active, :archived ]
+  #     enum :status, [ :active, :archived ]
   #   end
   #
   #   # conversation.update! status: 0
@@ -41,26 +42,33 @@ module ActiveRecord
   #   Conversation.where(status: [:active, :archived])
   #   Conversation.where.not(status: :active)
   #
-  # Defining scopes can be disabled by setting +:_scopes+ to +false+.
+  # Defining scopes can be disabled by setting +:scopes+ to +false+.
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [ :active, :archived ], _scopes: false
+  #     enum :status, [ :active, :archived ], scopes: false
   #   end
   #
-  # You can set the default enum value by setting +:_default+, like:
+  # You can set the default enum value by setting +:default+, like:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [ :active, :archived ], _default: "active"
+  #     enum :status, [ :active, :archived ], default: :active
   #   end
   #
   #   conversation = Conversation.new
   #   conversation.status # => "active"
   #
-  # Finally, it's also possible to explicitly map the relation between attribute and
+  # It's possible to explicitly map the relation between attribute and
   # database integer with a hash:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: { active: 0, archived: 1 }
+  #     enum :status, active: 0, archived: 1
+  #   end
+  #
+  # Finally it's also possible to use a string column to persist the enumerated value.
+  # Note that this will likely lead to slower database queries:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, active: "active", archived: "archived"
   #   end
   #
   # Note that when an array is used, the implicit mapping from the values to database
@@ -75,7 +83,7 @@ module ActiveRecord
   #
   # In rare circumstances you might need to access the mapping directly.
   # The mappings are exposed through a class method with the pluralized attribute
-  # name, which return the mapping in a +HashWithIndifferentAccess+:
+  # name, which return the mapping in a ActiveSupport::HashWithIndifferentAccess :
   #
   #   Conversation.statuses[:active]    # => 0
   #   Conversation.statuses["archived"] # => 1
@@ -85,14 +93,14 @@ module ActiveRecord
   #
   #   Conversation.where("status <> ?", Conversation.statuses[:archived])
   #
-  # You can use the +:_prefix+ or +:_suffix+ options when you need to define
+  # You can use the +:prefix+ or +:suffix+ options when you need to define
   # multiple enums with same values. If the passed value is +true+, the methods
   # are prefixed/suffixed with the name of the enum. It is also possible to
   # supply a custom value:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [:active, :archived], _suffix: true
-  #     enum comments_status: [:active, :inactive], _prefix: :comments
+  #     enum :status, [ :active, :archived ], suffix: true
+  #     enum :comments_status, [ :active, :inactive ], prefix: :comments
   #   end
   #
   # With the above example, the bang and predicate methods along with the
@@ -103,7 +111,6 @@ module ActiveRecord
   #
   #   conversation.comments_inactive!
   #   conversation.comments_active? # => false
-
   module Enum
     def self.extended(base) # :nodoc:
       base.class_attribute(:defined_enums, instance_writer: false, default: {})
@@ -128,10 +135,8 @@ module ActiveRecord
           value.to_s
         elsif mapping.has_value?(value)
           mapping.key(value)
-        elsif value.blank?
-          nil
         else
-          assert_valid_value(value)
+          value.presence
         end
       end
 
@@ -140,7 +145,11 @@ module ActiveRecord
       end
 
       def serialize(value)
-        mapping.fetch(value, value)
+        subtype.serialize(mapping.fetch(value, value))
+      end
+
+      def serializable?(value, &block)
+        subtype.serializable?(mapping.fetch(value, value), &block)
       end
 
       def assert_valid_value(value)
@@ -155,15 +164,20 @@ module ActiveRecord
         attr_reader :name, :mapping
     end
 
-    def enum(definitions)
-      enum_prefix = definitions.delete(:_prefix)
-      enum_suffix = definitions.delete(:_suffix)
-      enum_scopes = definitions.delete(:_scopes)
+    def enum(name = nil, values = nil, **options)
+      if name
+        values, options = options, {} unless values
+        return _enum(name, values, **options)
+      end
+
+      definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default)
+      options.transform_keys! { |key| :"#{key[1..-1]}" }
 
-      default = {}
-      default[:default] = definitions.delete(:_default) if definitions.key?(:_default)
+      definitions.each { |name, values| _enum(name, values, **options) }
+    end
 
-      definitions.each do |name, values|
+    private
+      def _enum(name, values, prefix: nil, suffix: nil, scopes: true, **options)
         assert_valid_enum_definition_values(values)
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
@@ -177,24 +191,19 @@ module ActiveRecord
         detect_enum_conflict!(name, name)
         detect_enum_conflict!(name, "#{name}=")
 
-        attr = attribute_alias?(name) ? attribute_alias(name) : name
-
-        decorate_attribute_type(attr, **default) do |subtype|
-          EnumType.new(attr, enum_values, subtype)
+        attribute(name, **options) do |subtype|
+          subtype = subtype.subtype if EnumType === subtype
+          EnumType.new(name, enum_values, subtype)
         end
 
         value_method_names = []
         _enum_methods_module.module_eval do
-          prefix = if enum_prefix == true
-            "#{name}_"
-          elsif enum_prefix
-            "#{enum_prefix}_"
+          prefix = if prefix
+            prefix == true ? "#{name}_" : "#{prefix}_"
           end
 
-          suffix = if enum_suffix == true
-            "_#{name}"
-          elsif enum_suffix
-            "_#{enum_suffix}"
+          suffix = if suffix
+            suffix == true ? "_#{name}" : "_#{suffix}"
           end
 
           pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
@@ -204,23 +213,21 @@ module ActiveRecord
 
             value_method_name = "#{prefix}#{label}#{suffix}"
             value_method_names << value_method_name
-            define_enum_methods(name, value_method_name, value, enum_scopes)
+            define_enum_methods(name, value_method_name, value, scopes)
 
             method_friendly_label = label.gsub(/[\W&&[:ascii:]]+/, "_")
             value_method_alias = "#{prefix}#{method_friendly_label}#{suffix}"
 
             if value_method_alias != value_method_name && !value_method_names.include?(value_method_alias)
               value_method_names << value_method_alias
-              define_enum_methods(name, value_method_alias, value, enum_scopes)
+              define_enum_methods(name, value_method_alias, value, scopes)
             end
           end
         end
-        detect_negative_enum_conditions!(value_method_names) if enum_scopes != false
+        detect_negative_enum_conditions!(value_method_names) if scopes
         enum_values.freeze
       end
-    end
 
-    private
       class EnumMethods < Module # :nodoc:
         def initialize(klass)
           @klass = klass
@@ -229,7 +236,7 @@ module ActiveRecord
         private
           attr_reader :klass
 
-          def define_enum_methods(name, value_method_name, value, enum_scopes)
+          def define_enum_methods(name, value_method_name, value, scopes)
             # def active?() status_for_database == 0 end
             klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
             define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
@@ -240,7 +247,7 @@ module ActiveRecord
 
             # scope :active, -> { where(status: 0) }
             # scope :not_active, -> { where.not(status: 0) }
-            if enum_scopes != false
+            if scopes
               klass.send(:detect_enum_conflict!, name, value_method_name, true)
               klass.scope value_method_name, -> { where(name => value) }
 
@@ -260,7 +267,7 @@ module ActiveRecord
       end
 
       def assert_valid_enum_definition_values(values)
-        unless values.is_a?(Hash) || values.all? { |v| v.is_a?(Symbol) } || values.all? { |v| v.is_a?(String) }
+        unless values.is_a?(Hash) || values.all?(Symbol) || values.all?(String)
           error_message = <<~MSG
             Enum values #{values} must be either a hash, an array of symbols, or an array of strings.
           MSG

data/lib/active_record/errors.rb

@@ -63,6 +63,30 @@ module ActiveRecord
   class ConnectionTimeoutError < ConnectionNotEstablished
   end
 
+  # Raised when connection to the database could not been established because it was not
+  # able to connect to the host or when the authorization failed.
+  class DatabaseConnectionError < ConnectionNotEstablished
+    def initialize(message = nil)
+      super(message || "Database connection error")
+    end
+
+    class << self
+      def hostname_error(hostname)
+        DatabaseConnectionError.new(<<~MSG)
+          There is an issue connecting with your hostname: #{hostname}.\n
+          Please check your database configuration and ensure there is a valid connection to your database.
+        MSG
+      end
+
+      def username_error(username)
+        DatabaseConnectionError.new(<<~MSG)
+          There is an issue connecting to your database with your username/password, username: #{username}.\n
+          Please check your database configuration to ensure the username/password are valid.
+        MSG
+      end
+    end
+  end
+
   # Raised when a pool was unable to get ahold of all its connections
   # to perform a "group" action such as
   # {ActiveRecord::Base.connection_pool.disconnect!}[rdoc-ref:ConnectionAdapters::ConnectionPool#disconnect!]
@@ -100,7 +124,7 @@ module ActiveRecord
   end
 
   # Raised by {ActiveRecord::Base#destroy!}[rdoc-ref:Persistence#destroy!]
-  # when a call to {#destroy}[rdoc-ref:Persistence#destroy!]
+  # when a call to {#destroy}[rdoc-ref:Persistence#destroy]
   # would return false.
   #
   #   begin
@@ -118,6 +142,16 @@ module ActiveRecord
     end
   end
 
+  # Raised when Active Record finds multiple records but only expected one.
+  class SoleRecordExceeded < ActiveRecordError
+    attr_reader :record
+
+    def initialize(record = nil)
+      @record = record
+      super "Wanted only one #{record&.name || "record"}"
+    end
+  end
+
   # Superclass for all database execution errors.
   #
   # Wraps the underlying database error as +cause+.
@@ -202,6 +236,30 @@ module ActiveRecord
 
   # Raised when a given database does not exist.
   class NoDatabaseError < StatementInvalid
+    include ActiveSupport::ActionableError
+
+    action "Create database" do
+      ActiveRecord::Tasks::DatabaseTasks.create_current
+    end
+
+    def initialize(message = nil)
+      super(message || "Database not found")
+    end
+
+    class << self
+      def db_error(db_name)
+        NoDatabaseError.new(<<~MSG)
+          We could not find your database: #{db_name}. Which can be found in the database configuration file located at config/database.yml.
+
+          To resolve this issue:
+
+          - Did you create the database for this app, or delete it? You may need to create your database.
+          - Has the database name changed? Check your database.yml config has the correct database name.
+
+          To create your database, run:\n\n        bin/rails db:create
+        MSG
+      end
+    end
   end
 
   # Raised when creating a database if it exists.
@@ -268,7 +326,7 @@ module ActiveRecord
   #           # The system must fail on Friday so that our support department
   #           # won't be out of job. We silently rollback this transaction
   #           # without telling the user.
-  #           raise ActiveRecord::Rollback, "Call tech support!"
+  #           raise ActiveRecord::Rollback
   #         end
   #       end
   #       # ActiveRecord::Rollback is the only exception that won't be passed on
@@ -363,6 +421,11 @@ module ActiveRecord
   class TransactionRollbackError < StatementInvalid
   end
 
+  # AsynchronousQueryInsideTransactionError will be raised when attempting
+  # to perform an asynchronous query from inside a transaction
+  class AsynchronousQueryInsideTransactionError < ActiveRecordError
+  end
+
   # SerializationFailure will be raised when a transaction is rolled
   # back by the database due to a serialization failure.
   class SerializationFailure < TransactionRollbackError
@@ -409,12 +472,12 @@ module ActiveRecord
   #
   # For example, the following code would raise this exception:
   #
-  #   Post.order("length(title)").first
+  #   Post.order("REPLACE(title, 'misc', 'zzzz') asc").pluck(:id)
   #
   # The desired result can be accomplished by wrapping the known-safe string
   # in Arel.sql:
   #
-  #   Post.order(Arel.sql("length(title)")).first
+  #   Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz') asc")).pluck(:id)
   #
   # Again, such a workaround should *not* be used when passing user-provided
   # values, such as request parameters or model attributes to query methods.

data/lib/active_record/explain_registry.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/per_thread_registry"
+require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   # This is a thread locals registry for EXPLAIN. For example
@@ -8,13 +8,18 @@ module ActiveRecord
   #   ActiveRecord::ExplainRegistry.queries
   #
   # returns the collected queries local to the current thread.
-  #
-  # See the documentation of ActiveSupport::PerThreadRegistry
-  # for further details.
   class ExplainRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
+    class << self
+      delegate :reset, :collect, :collect=, :collect?, :queries, to: :instance
+
+      private
+        def instance
+          ActiveSupport::IsolatedExecutionState[:active_record_explain_registry] ||= new
+        end
+    end
 
-    attr_accessor :queries, :collect
+    attr_accessor :collect
+    attr_reader :queries
 
     def initialize
       reset

data/lib/active_record/explain_subscriber.rb

@@ -21,7 +21,7 @@ module ActiveRecord
     # On the other hand, we want to monitor the performance of our real database
     # queries, not the performance of the access to the query cache.
     IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
-    EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
+    EXPLAINED_SQLS = /\A\s*(\/\*.*\*\/)?\s*(with|select|update|delete|insert)\b/i
     def ignore_payload?(payload)
       payload[:exception] ||
         payload[:cached] ||

data/lib/active_record/fixture_set/file.rb

@@ -41,7 +41,7 @@ module ActiveRecord
           @config_row ||= begin
             row = raw_rows.find { |fixture_name, _| fixture_name == "_fixture" }
             if row
-              row.last
+              validate_config_row(row.last)
             else
               { 'model_class': nil, 'ignore': nil }
             end
@@ -58,6 +58,20 @@ module ActiveRecord
           end
         end
 
+        def validate_config_row(data)
+          unless Hash === data
+            raise Fixture::FormatError, "Invalid `_fixture` section: `_fixture` must be a hash: #{@file}"
+          end
+
+          begin
+            data.assert_valid_keys("model_class", "ignore")
+          rescue ArgumentError => error
+            raise Fixture::FormatError, "Invalid `_fixture` section: #{error.message}: #{@file}"
+          end
+
+          data
+        end
+
         # Validate our unmarshalled data.
         def validate(data)
           unless Hash === data || YAML::Omap === data