mongoid 9.0.2 → 9.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 558b30b0a39cd36cd9a3e54695f4617a9fcc0d67300637d1299b487b7d911bda
-  data.tar.gz: eccf9c55bdde17fd38592427e0dd6b5545d3e605b94a4308a422ba332e20c183
+  metadata.gz: 3ac7ac8e60ba9d953a5a809d17b7fca7a2501988cdec50d12348af3b7022f615
+  data.tar.gz: 27a2bceb132e4f6b33d8be6b70ac8074b8de421c5c1efdb03f3ad2fc97d62364
 SHA512:
-  metadata.gz: 420ac9d23abeecb04c19794df124fc80d4f99883e1156d4e3be42e79b4b2e5e5a558c6b650746784024f0477a800def3a2ded537b848d3e9b97fb5e5e220b1f0
-  data.tar.gz: 40bfdcaf862e3ae7d3d046d84d5f9f5eea4752b5559c869eda16e1bd00cbc9aaae3eef05a7e4bec497915619fb162a248ac8f4be3525068e81f28ae876af1a29
+  metadata.gz: 31cea6e77afe05358ff9cdaf5bc861807a93ce9c89e7cfd9209c0f35a2df816fb8d4d595faafbab2665b2dab776f523d0b96eece4b249626f976ec685765d5a5
+  data.tar.gz: 1367fb446dae452b73227c099e72ed2f13bd2702434e8050c09f3c1ae2ad97b5346371252ce3cfa3442151353bd8c8ef9a409cd2de75edb7cdf20ff3322107c7

data/lib/mongoid/attributes/readonly.rb

@@ -23,7 +23,7 @@ module Mongoid
       # @return [ true | false ] If the document is new, or if the field is not
       #   readonly.
       def attribute_writable?(name)
-        new_record? || (!readonly_attributes.include?(name) && _loaded?(name))
+        new_record? || (!self.class.readonly_attributes.include?(name) && _loaded?(name))
       end
 
       private
@@ -63,12 +63,17 @@ module Mongoid
         #   end
         #
         # @param [ Symbol... ] *names The names of the fields.
+        # @note When a parent class contains readonly attributes and is then
+        # inherited by a child class, the child class will inherit the
+        # parent's readonly attributes at the time of its creation.
+        # Updating the parent does not propagate down to child classes after wards.
         def attr_readonly(*names)
+          self.readonly_attributes = self.readonly_attributes.dup
           names.each do |name|
-            readonly_attributes << database_field_name(name)
+            self.readonly_attributes << database_field_name(name)
           end
         end
       end
     end
   end
-end
+end

data/lib/mongoid/clients/options.rb

@@ -86,7 +86,7 @@ module Mongoid
         else
           PersistenceContext.get(self) ||
             PersistenceContext.get(self.class) ||
-            PersistenceContext.new(self.class, storage_options)
+            PersistenceContext.new(self.class, default_storage_options)
         end
       end
 
@@ -112,6 +112,19 @@ module Mongoid
 
       private
 
+      def default_storage_options
+        # Nothing is overridden, we use either the default storage_options
+        # or storage_options defined for the document class.
+        return storage_options if Threaded.client_override.nil? && Threaded.database_override.nil?
+
+        storage_options.tap do |opts|
+          # Globally overridden client replaces client defined for the document class.
+          opts[:client] = Threaded.client_override unless Threaded.client_override.nil?
+          # Globally overridden database replaces database defined for the document class.
+          opts[:database] = Threaded.database_override unless Threaded.database_override.nil?
+        end
+      end
+
       def set_persistence_context(options_or_context)
         PersistenceContext.set(self, options_or_context)
       end

data/lib/mongoid/clients/sessions.rb

@@ -62,6 +62,7 @@ module Mongoid
         rescue *transactions_not_supported_exceptions
           raise Mongoid::Errors::TransactionsNotSupported
         ensure
+          Threaded.clear_modified_documents(session)
           Threaded.clear_session(client: persistence_context.client)
         end
 

data/lib/mongoid/criteria/queryable/selectable.rb

@@ -553,7 +553,7 @@ module Mongoid
         # @return [ Selectable ] The new selectable.
         def not(*criteria)
           if criteria.empty?
-            dup.tap { |query| query.negating = true }
+            dup.tap { |query| query.negating = !query.negating }
           else
             criteria.compact.inject(self.clone) do |c, new_s|
               if new_s.is_a?(Selectable)

data/lib/mongoid/equality.rb

@@ -18,6 +18,7 @@ module Mongoid
     #
     # @return [ Integer ] -1, 0, 1.
     def <=>(other)
+      return super unless other.is_a?(Mongoid::Equality)
       attributes["_id"].to_s <=> other.attributes["_id"].to_s
     end
 

data/lib/mongoid/loadable.rb

@@ -10,6 +10,13 @@ module Mongoid
     # (See #model_paths.)
     DEFAULT_MODEL_PATHS = %w( ./app/models ./lib/models ).freeze
 
+    # The default list of glob patterns that match paths to ignore when loading
+    # models. Defaults to '*/models/concerns/*', which Rails uses for extensions
+    # to models (and which cause errors when loaded out of order).
+    #
+    # See #ignore_patterns.
+    DEFAULT_IGNORE_PATTERNS = %w( */models/concerns/* ).freeze
+
     # Search a list of model paths to get every model and require it, so
     # that indexing and inheritance work in both development and production
     # with the same results.
@@ -24,17 +31,47 @@ module Mongoid
     #   for model files. These must either be absolute paths, or relative to
     #   the current working directory.
     def load_models(paths = model_paths)
-      paths.each do |path|
-        if preload_models.resizable?
-          files = preload_models.map { |model| "#{path}/#{model.underscore}.rb" }
+      files = files_under_paths(paths)
+
+      files.sort.each do |file|
+        load_model(file)
+      end
+
+      nil
+    end
+
+    # Given a list of paths, return all ruby files under that path (or, if
+    # `preload_models` is a list of model names, returns only the files for
+    # those named models).
+    #
+    # @param [ Array<String> ] paths the list of paths to search
+    #
+    # @return [ Array<String> ] the normalized file names, suitable for loading
+    #   via `require_dependency` or `require`.
+    def files_under_paths(paths)
+      paths.flat_map { |path| files_under_path(path) }
+    end
+
+    # Given a single path, returns all ruby files under that path (or, if
+    # `preload_models` is a list of model names, returns only the files for
+    # those named models).
+    #
+    # @param [ String ] path the path to search
+    #
+    # @return [ Array<String> ] the normalized file names, suitable for loading
+    #   via `require_dependency` or `require`.
+    def files_under_path(path)
+      files = if preload_models.resizable?
+          preload_models.
+            map { |model| "#{path}/#{model.underscore}.rb" }.
+            select { |file_name| File.exists?(file_name) }
         else
-          files = Dir.glob("#{path}/**/*.rb")
+          Dir.glob("#{path}/**/*.rb").
+            reject { |file_name| ignored?(file_name) }
         end
 
-        files.sort.each do |file|
-          load_model(file.gsub(/^#{path}\// , "").gsub(/\.rb$/, ""))
-        end
-      end
+      # strip the path and the suffix from each entry
+      files.map { |file| file.gsub(/^#{path}\// , "").gsub(/\.rb$/, "") }
     end
 
     # A convenience method for loading a model's file. If Rails'
@@ -71,6 +108,14 @@ module Mongoid
         DEFAULT_MODEL_PATHS
     end
 
+    # Returns the array of glob patterns that determine whether a given
+    # path should be ignored by the model loader.
+    #
+    # @return [ Array<String> ] the array of ignore patterns
+    def ignore_patterns
+      @ignore_patterns ||= DEFAULT_IGNORE_PATTERNS.dup
+    end
+
     # Sets the model paths to the given array of paths. These are the paths
     # where the application's model definitions are located.
     #
@@ -78,6 +123,25 @@ module Mongoid
     def model_paths=(paths)
       @model_paths = paths
     end
+
+    # Sets the ignore patterns to the given array of patterns. These are glob
+    # patterns that determine whether a given path should be ignored by the
+    # model loader or not.
+    #
+    # @param [ Array<String> ] patterns The list of glob patterns
+    def ignore_patterns=(patterns)
+      @ignore_patterns = patterns
+    end
+
+    # Returns true if the given file path matches any of the ignore patterns.
+    #
+    # @param [ String ] file_path The file path to consider
+    #
+    # @return [ true | false ] whether or not the given file path should be
+    #   ignored.
+    def ignored?(file_path)
+      ignore_patterns.any? { |pattern| File.fnmatch?(pattern, file_path) }
+    end
   end
 
 end

data/lib/mongoid/matcher.rb

@@ -39,11 +39,25 @@ module Mongoid
     # from and behaves identically to association traversal for the purposes
     # of, for example, subsequent array element retrieval.
     #
-    # @param [ Document | Hash ] document The document to extract from.
+    # @param [ Document | Hash | String ] document The document to extract from.
     # @param [ String ] key The key path to extract.
     #
     # @return [ Object | Array ] Field value or values.
     module_function def extract_attribute(document, key)
+      # The matcher system will wind up sending atomic values to this as well,
+      # when attepting to match more complex types. If anything other than a
+      # Document or a Hash is given, we'll short-circuit the logic and just
+      # return an empty array.
+      return [] unless document.is_a?(Hash) || document.is_a?(Document)
+
+      # Performance optimization; if the key does not include a '.' character,
+      # it must reference an immediate attribute of the document.
+      unless key.include?('.')
+        hash = document.respond_to?(:attributes) ? document.attributes : document
+        key = find_exact_key(hash, key)
+        return key ? [ hash[key] ] : []
+      end
+
       if document.respond_to?(:as_attributes, true)
         # If a document has hash fields, as_attributes would keep those fields
         # as Hash instances which do not offer indifferent access.

data/lib/mongoid/persistence_context.rb

@@ -117,12 +117,15 @@ module Mongoid
     def client
       @client ||= begin
         client = Clients.with_name(client_name)
+        options = client_options
+
         if database_name_option
           client = client.use(database_name)
+          options = options.except(:database, 'database')
         end
-        unless client_options.empty?
-          client = client.with(client_options)
-        end
+
+        client = client.with(options) unless options.empty?
+
         client
       end
     end
@@ -135,7 +138,7 @@ module Mongoid
     # @return [ Symbol ] The client name for this persistence
     #   context.
     def client_name
-      @client_name ||= options[:client] ||
+      @client_name ||= __evaluate__(options[:client]) ||
                          Threaded.client_override ||
                          __evaluate__(storage_options[:client])
     end
@@ -282,6 +285,10 @@ module Mongoid
       # @api private
       PERSISTENCE_CONTEXT_KEY = :"[mongoid]:persistence_context"
 
+      def context_store
+        Threaded.get(PERSISTENCE_CONTEXT_KEY) { {} }
+      end
+
       # Get the persistence context for a given object from the thread local
       #   storage.
       #
@@ -292,8 +299,7 @@ module Mongoid
       #
       # @api private
       def get_context(object)
-        Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
-        Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id]
+        context_store[object.object_id]
       end
 
       # Store persistence context for a given object in the thread local
@@ -305,10 +311,9 @@ module Mongoid
       # @api private
       def store_context(object, context)
         if context.nil?
-          Thread.current[PERSISTENCE_CONTEXT_KEY]&.delete(object.object_id)
+          context_store.delete(object.object_id)
         else
-          Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
-          Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id] = context
+          context_store[object.object_id] = context
         end
       end
     end

data/lib/mongoid/railties/controller_runtime.rb

@@ -78,7 +78,7 @@ module Mongoid
         #
         # @return [ Integer ] The runtime value.
         def self.runtime
-          Thread.current[VARIABLE_NAME] ||= 0
+          Threaded.get(VARIABLE_NAME) { 0 }
         end
 
         # Set the runtime value on the current thread.
@@ -87,7 +87,7 @@ module Mongoid
         #
         # @return [ Integer ] The runtime value.
         def self.runtime= value
-          Thread.current[VARIABLE_NAME] = value
+          Threaded.set(VARIABLE_NAME, value)
         end
 
         # Reset the runtime value to zero the current thread.

data/lib/mongoid/serializable.rb

@@ -13,13 +13,13 @@ module Mongoid
     included do
 
       class << self
-        # Note that this intentionally only delegates :include_root_in_json
-        # and not :include_root_in_json? - delegating the latter produces
-        # wrong behavior.
-        # Also note that this intentionally uses the ActiveSupport delegation
-        # functionality and not the Ruby standard library one.
-        # See https://jira.mongodb.org/browse/MONGOID-4849.
-        delegate :include_root_in_json, to: ::Mongoid
+        def include_root_in_json
+          @include_root_in_json.nil? ? ::Mongoid.include_root_in_json : @include_root_in_json
+        end
+
+        def include_root_in_json=(new_value)
+          @include_root_in_json = new_value
+        end
       end
     end
 

data/lib/mongoid/threaded.rb

@@ -18,6 +18,7 @@ module Mongoid
     CURRENT_SCOPE_KEY = '[mongoid]:current-scope'
 
     AUTOSAVES_KEY = '[mongoid]:autosaves'
+
     VALIDATIONS_KEY = '[mongoid]:validations'
 
     STACK_KEYS = Hash.new do |hash, key|
@@ -36,6 +37,75 @@ module Mongoid
 
     extend self
 
+    # Queries the thread-local variable with the given name. If a block is
+    # given, and the variable does not already exist, the return value of the
+    # block will be set as the value of the variable before returning it.
+    #
+    # It is very important that applications (and espcially Mongoid)
+    # use this method instead of Thread#[], since Thread#[] is actually for
+    # fiber-local variables, and Mongoid uses Fibers as an implementation
+    # detail in some callbacks. Putting thread-local state in a fiber-local
+    # store will result in the state being invisible when relevant callbacks are
+    # run in a different fiber.
+    #
+    # Affected callbacks are cascading callbacks on embedded children.
+    #
+    # @param [ String | Symbol ] key the name of the variable to query
+    # @param [ Proc ] default an optional block that must return the default
+    #   (initial) value of this variable.
+    #
+    # @return [ Object | nil ] the value of the queried variable, or nil if
+    #   it is not set and no default was given.
+    def get(key, &default)
+      result = Thread.current.thread_variable_get(key)
+
+      if result.nil? && default
+        result = yield
+        set(key, result)
+      end
+
+      result
+    end
+
+    # Sets a thread-local variable with the given name to the given value.
+    # See #get for a discussion of why this method is necessary, and why
+    # Thread#[]= should be avoided in cascading callbacks on embedded children.
+    #
+    # @param [ String | Symbol ] key the name of the variable to set.
+    # @param [ Object | nil ] value the value of the variable to set (or `nil`
+    #   if you wish to unset the variable)
+    def set(key, value)
+      Thread.current.thread_variable_set(key, value)
+    end
+
+    # Removes the named variable from thread-local storage.
+    #
+    # @param [ String | Symbol ] key the name of the variable to remove.
+    def delete(key)
+      set(key, nil)
+    end
+
+    # Queries the presence of a named variable in thread-local storage.
+    #
+    # @param [ String | Symbol ] key the name of the variable to query.
+    #
+    # @return [ true | false ] whether the given variable is present or not.
+    def has?(key)
+      # Here we have a classic example of JRuby not behaving like MRI. In
+      # MRI, if you set a thread variable to nil, it removes it from the list
+      # and subsequent calls to thread_variable?(key) will return false. Not
+      # so with JRuby. Once set, you cannot unset the thread variable.
+      #
+      # However, because setting a variable to nil is supposed to remove it,
+      # we can assume a nil-valued variable doesn't actually exist.
+
+      # So, instead of this:
+      # Thread.current.thread_variable?(key)
+
+      # We have to do this:
+      !get(key).nil?
+    end
+
     # Begin entry into a named thread local stack.
     #
     # @example Begin entry into the stack.
@@ -55,7 +125,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def database_override
-      Thread.current[DATABASE_OVERRIDE_KEY]
+      get(DATABASE_OVERRIDE_KEY)
     end
 
     # Set the global database override.
@@ -67,7 +137,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def database_override=(name)
-      Thread.current[DATABASE_OVERRIDE_KEY] = name
+      set(DATABASE_OVERRIDE_KEY, name)
     end
 
     # Are in the middle of executing the named stack
@@ -103,7 +173,7 @@ module Mongoid
     #
     # @return [ Array ] The stack.
     def stack(name)
-      Thread.current[STACK_KEYS[name]] ||= []
+      get(STACK_KEYS[name]) { [] }
     end
 
     # Begin autosaving a document on the current thread.
@@ -177,7 +247,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def client_override
-      Thread.current[CLIENT_OVERRIDE_KEY]
+      get(CLIENT_OVERRIDE_KEY)
     end
 
     # Set the global client override.
@@ -189,7 +259,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def client_override=(name)
-      Thread.current[CLIENT_OVERRIDE_KEY] = name
+      set(CLIENT_OVERRIDE_KEY, name)
     end
 
     # Get the current Mongoid scope.
@@ -202,12 +272,12 @@ module Mongoid
     #
     # @return [ Criteria ] The scope.
     def current_scope(klass = nil)
-      if klass && Thread.current[CURRENT_SCOPE_KEY].respond_to?(:keys)
-        Thread.current[CURRENT_SCOPE_KEY][
-            Thread.current[CURRENT_SCOPE_KEY].keys.find { |k| k <= klass }
-        ]
+      current_scope = get(CURRENT_SCOPE_KEY)
+
+      if klass && current_scope.respond_to?(:keys)
+        current_scope[current_scope.keys.find { |k| k <= klass }]
       else
-        Thread.current[CURRENT_SCOPE_KEY]
+        current_scope
       end
     end
 
@@ -220,7 +290,7 @@ module Mongoid
     #
     # @return [ Criteria ] The scope.
     def current_scope=(scope)
-      Thread.current[CURRENT_SCOPE_KEY] = scope
+      set(CURRENT_SCOPE_KEY, scope)
     end
 
     # Set the current Mongoid scope. Safe for multi-model scope chaining.
@@ -236,8 +306,8 @@ module Mongoid
       if scope.nil?
         unset_current_scope(klass)
       else
-        Thread.current[CURRENT_SCOPE_KEY] ||= {}
-        Thread.current[CURRENT_SCOPE_KEY][klass] = scope
+        current_scope = get(CURRENT_SCOPE_KEY) { {} }
+        current_scope[klass] = scope
       end
     end
 
@@ -284,7 +354,7 @@ module Mongoid
     #
     # @return [ Hash ] The current autosaves.
     def autosaves
-      Thread.current[AUTOSAVES_KEY] ||= {}
+      get(AUTOSAVES_KEY) { {} }
     end
 
     # Get all validations on the current thread.
@@ -294,7 +364,7 @@ module Mongoid
     #
     # @return [ Hash ] The current validations.
     def validations
-      Thread.current[VALIDATIONS_KEY] ||= {}
+      get(VALIDATIONS_KEY) { {} }
     end
 
     # Get all autosaves on the current thread for the class.
@@ -376,9 +446,7 @@ module Mongoid
     # @return [ Set<Mongoid::Document> ] Collection of modified documents before
     #   it was cleared.
     def clear_modified_documents(session)
-      modified_documents[session].dup
-    ensure
-      modified_documents[session].clear
+      modified_documents.delete(session) || []
     end
 
     # Queries whether document callbacks should be executed by default for the
@@ -390,8 +458,8 @@ module Mongoid
     # @return [ true | false ] Whether or not document callbacks should be
     #   executed by default.
     def execute_callbacks?
-      if Thread.current.key?(EXECUTE_CALLBACKS)
-        Thread.current[EXECUTE_CALLBACKS]
+      if has?(EXECUTE_CALLBACKS)
+        get(EXECUTE_CALLBACKS)
       else
         true
       end
@@ -404,7 +472,7 @@ module Mongoid
     # @param flag [ true | false ] Whether or not document callbacks should be
     #   executed by default.
     def execute_callbacks=(flag)
-      Thread.current[EXECUTE_CALLBACKS] = flag
+      set(EXECUTE_CALLBACKS, flag)
     end
 
     # Returns the thread store of sessions.
@@ -413,7 +481,7 @@ module Mongoid
     #
     # @api private
     def sessions
-      Thread.current[SESSIONS_KEY] ||= {}.compare_by_identity
+      get(SESSIONS_KEY) { {}.compare_by_identity }
     end
 
     # Returns the thread store of modified documents.
@@ -423,9 +491,7 @@ module Mongoid
     #
     # @api private
     def modified_documents
-      Thread.current[MODIFIED_DOCUMENTS_KEY] ||= Hash.new do |h, k|
-        h[k] = Set.new
-      end
+      get(MODIFIED_DOCUMENTS_KEY) { Hash.new { |h, k| h[k] = Set.new } }
     end
 
     private
@@ -435,10 +501,12 @@ module Mongoid
     #
     # @param klass [ Class ] the class to remove from the current scope.
     def unset_current_scope(klass)
-      return unless Thread.current[CURRENT_SCOPE_KEY]
+      return unless has?(CURRENT_SCOPE_KEY)
+
+      scope = get(CURRENT_SCOPE_KEY)
+      scope.delete(klass)
 
-      Thread.current[CURRENT_SCOPE_KEY].delete(klass)
-      Thread.current[CURRENT_SCOPE_KEY] = nil if Thread.current[CURRENT_SCOPE_KEY].empty?
+      delete(CURRENT_SCOPE_KEY) if scope.empty?
     end
   end
 end

data/lib/mongoid/timestamps/timeless.rb

@@ -46,6 +46,9 @@ module Mongoid
       class << self
         extend Forwardable
 
+        # The key to use to store the timeless table 
+        TIMELESS_TABLE_KEY = '[mongoid]:timeless'
+
         # Returns the in-memory thread cache of classes
         # for which to skip timestamping.
         #
@@ -53,7 +56,7 @@ module Mongoid
         #
         # @api private
         def timeless_table
-          Thread.current['[mongoid]:timeless'] ||= Hash.new
+          Threaded.get(TIMELESS_TABLE_KEY) { Hash.new }
         end
 
         def_delegators :timeless_table, :[]=, :[]

data/lib/mongoid/touchable.rb

@@ -195,7 +195,7 @@ module Mongoid
     # @return [ Hash ] The hash that contains touch callback suppression
     #   statuses
     def touch_callback_statuses
-      Thread.current[SUPPRESS_TOUCH_CALLBACKS_KEY] ||= {}
+      Threaded.get(SUPPRESS_TOUCH_CALLBACKS_KEY) { {} }
     end
 
     # Define the method that will get called for touching belongs_to

data/lib/mongoid/traversable.rb

@@ -8,6 +8,29 @@ module Mongoid
   # around traversing the document graph.
   module Traversable
     extend ActiveSupport::Concern
+    # This code is extracted from ActiveSupport so that we do not depend on
+    # their private API that may change at any time.
+    # This code should be reviewed and maybe removed when implementing
+    # https://jira.mongodb.org/browse/MONGOID-5832
+    class << self
+      # @api private
+      def __redefine(owner, name, value)
+        if owner.singleton_class?
+          owner.redefine_method(name) { value }
+          owner.send(:public, name)
+        end
+        owner.redefine_singleton_method(name) { value }
+        owner.singleton_class.send(:public, name)
+        owner.redefine_singleton_method("#{name}=") do |new_value|
+          if owner.equal?(self)
+            value = new_value
+          else
+            ::Mongoid::Traversable.redefine(self, name, new_value)
+          end
+        end
+        owner.singleton_class.send(:public, "#{name}=")
+      end
+    end
 
     # Class-level methods for the Traversable behavior.
     module ClassMethods
@@ -105,7 +128,7 @@ module Mongoid
         if value
           Mongoid::Fields::Validators::Macro.validate_field_name(self, value)
           value = value.to_s
-          super
+          ::Mongoid::Traversable.__redefine(self, 'discriminator_key', value)
         else
           # When discriminator key is set to nil, replace the class's definition
           # of the discriminator key reader (provided by class_attribute earlier)
@@ -119,7 +142,7 @@ module Mongoid
         # an existing field.
         # This condition also checks if the class has any descendants, because
         # if it doesn't then it doesn't need a discriminator key.
-        return unless !fields.key?(discriminator_key) && !descendants.empty?
+        return if fields.key?(discriminator_key) || descendants.empty?
 
         default_proc = -> { self.class.discriminator_value }
         field(discriminator_key, default: default_proc, type: String)