mongoid 9.1.0 → 9.1.1

data/lib/mongoid/association/nested/many.rb

@@ -179,7 +179,7 @@ module Mongoid
         # @param [ Hash ] attrs The single document attributes to process.
         def update_nested_relation(parent, id, attrs)
           first = existing.first
-          converted = first ? convert_id(first.class, id) : id
+          converted = convert_id(first ? first.class : association.klass, id)
 
           if existing.where(_id: converted).exists?
             # document exists in association
@@ -191,19 +191,48 @@ module Mongoid
             end
           elsif association.embedded?
             raise Errors::DocumentNotFound.new(association.klass, id)
-          elsif association.is_a?(Association::Referenced::HasAndBelongsToMany) || Mongoid.allow_reparenting_via_nested_attributes?
-            Mongoid::Warnings.warn_reparenting_via_nested_attributes if Mongoid.allow_reparenting_via_nested_attributes?
+          elsif destroyable?(attrs)
+            # A destroy of a document that is not in the association is
+            # ignored, rather than reaching for it outside the association.
+            nil
+          elsif Mongoid.allow_reparenting_via_nested_attributes?
+            Mongoid::Warnings.warn_reparenting_via_nested_attributes
 
             # push existing document to association
             doc = association.klass.unscoped.find(converted)
+            # find returns nil instead of raising when
+            # Mongoid.raise_not_found_error is false; a missing document
+            # must still be an error here, consistent with the other
+            # not-found branches.
+            raise Errors::DocumentNotFound.new(association.klass, id) if doc.nil?
+
             update_document(doc, attrs)
-            existing.push(doc) unless destroyable?(attrs)
+            existing.push(doc)
           else
-            raise Errors::DocumentNotFound.new(association.klass, { _id: id, association.foreign_key => parent.id })
+            raise Errors::DocumentNotFound.new(association.klass, not_found_params(parent, id))
           end
 
           parent.children_may_have_changed!
         end
+
+        # The params to report when an id in the nested attributes could not
+        # be resolved within the association.
+        #
+        # @api private
+        #
+        # @param [ Document ] parent The parent document.
+        # @param [ String | BSON::ObjectId ] id of the related document.
+        #
+        # @return [ Hash | Object ] The params for the not found error.
+        def not_found_params(parent, id)
+          if association.is_a?(Association::Referenced::HasAndBelongsToMany)
+            # A many-to-many association has no foreign key on the child, so
+            # the id is only ever resolved within the association itself.
+            id
+          else
+            { _id: id, association.foreign_key => parent.id }
+          end
+        end
       end
     end
   end

data/lib/mongoid/association/nested/nested_buildable.rb

@@ -55,12 +55,26 @@ module Mongoid
         # @example Convert the id.
         #   builder.convert_id(Person, "4d371b444835d98b8b000010")
         #
+        # Ids arriving from a form are always scalars. A Hash or an Array
+        # here means the parameters were crafted, and letting one through
+        # would turn the id into a query operator, so they are rejected.
+        #
         # @param [ Class ] klass The class we're trying to convert for.
         # @param [ String ] id The id, usually coming from the form.
         #
         # @return [ BSON::ObjectId | String | Object ] The converted id.
+        #
+        # @raise [ Errors::DocumentNotFound ] if the id is not a scalar, or
+        #   cannot be converted to the type the class uses for its ids.
+        #   The BSON::Error rescue is defensive: a value that reaches
+        #   BSON::ObjectId.mongoize and raises there must not surface as an
+        #   unhandled BSON error in the caller.
         def convert_id(klass, id)
+          raise Errors::DocumentNotFound.new(klass, id) if id.is_a?(::Hash) || id.is_a?(::Array)
+
           klass.using_object_ids? ? BSON::ObjectId.mongoize(id) : id
+        rescue BSON::Error
+          raise Errors::DocumentNotFound.new(klass, id)
         end
 
         private

data/lib/mongoid/association/nested/one.rb

@@ -26,7 +26,12 @@ module Mongoid
         def build(parent)
           return if reject?(parent, attributes)
 
-          @existing = parent.send(association.name)
+          @existing =
+            if association.fallback?
+              parent.send(:without_autobuild) { parent.send(association.name) }
+            else
+              parent.send(association.name)
+            end
           if update?
             delete_id(attributes)
             existing.assign_attributes(attributes)

data/lib/mongoid/association/options.rb

@@ -39,6 +39,23 @@ module Mongoid
         !!@options[:autobuild]
       end
 
+      # Invokes the :fallback Proc and returns the null object that stands in
+      # for the association when its actual value is nil. The Proc is invoked
+      # on every access; identity is the user's responsibility (return a fresh
+      # instance, a shared constant, or whatever the Proc chooses).
+      #
+      # @return [ Object | nil ] The Proc's return value, or nil if not set.
+      def fallback
+        @options[:fallback]&.call
+      end
+
+      # Whether the association has a :fallback (null object) option set.
+      #
+      # @return [ true | false ]
+      def fallback?
+        !@options[:fallback].nil?
+      end
+
       # Is the association cyclic.
       #
       # @return [ true | false ] Whether the association is cyclic.

data/lib/mongoid/association/referenced/belongs_to/eager.rb

@@ -24,10 +24,15 @@ module Mongoid
           # association is not polymorphic, all documents are retrieved in
           # a single query. If the association is polymorphic, one query is
           # issued per association target class.
+          #
+          # The polymorphic *_type field is resolved through the
+          # association's resolver to keep this path consistent with the
+          # non-eager accessor and to avoid loading arbitrary constants
+          # named in user-controlled BSON data.
           def each_loaded_document(&block)
             if @association.polymorphic?
               keys_by_type_from_docs.each do |type, keys|
-                each_loaded_document_of_class(Object.const_get(type), keys, &block)
+                each_loaded_document_of_class(@association.resolver.model_for(type), keys, &block)
               end
             else
               super

data/lib/mongoid/association/referenced/belongs_to.rb

@@ -22,6 +22,7 @@ module Mongoid
           autosave
           counter_cache
           dependent
+          fallback
           foreign_key
           index
           polymorphic

data/lib/mongoid/association/referenced/counter_cache.rb

@@ -110,7 +110,7 @@ module Mongoid
                   end
                 end
 
-                if (record = __send__(name)) && !current.nil?
+                if (record = without_autobuild { __send__(name) }) && !current.nil?
                   record[cache_column] = (record[cache_column] || 0) + 1
                   record.class.with(record.persistence_context) do |_class|
                     _class.increment_counter(cache_column, current) if record.persisted?
@@ -120,7 +120,7 @@ module Mongoid
             end
 
             klass.after_create do
-              if record = __send__(name)
+              if record = without_autobuild { __send__(name) }
                 record[cache_column] = (record[cache_column] || 0) + 1
 
                 if record.persisted?
@@ -133,7 +133,7 @@ module Mongoid
             end
 
             klass.before_destroy do
-              if record = __send__(name)
+              if record = without_autobuild { __send__(name) }
                 record[cache_column] = (record[cache_column] || 0) - 1 unless record.frozen?
 
                 if record.persisted?

data/lib/mongoid/association/referenced/has_and_belongs_to_many.rb

@@ -271,6 +271,11 @@ module Mongoid
           crit = relation_class.criteria
           crit = if id_list
                    crit = crit.apply_scope(scope)
+                   # A nil in the stored key array would match every document
+                   # whose primary key is null or absent, returning documents
+                   # that were never associated. Associating a target whose
+                   # custom primary key is unset stores such a nil.
+                   id_list = id_list.compact if id_list.is_a?(Array)
                    crit.all_of(primary_key => { '$in' => id_list })
                  else
                    crit.none

data/lib/mongoid/association/referenced/has_many/enumerable.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'mongoid/field_readable'
 require 'mongoid/pluckable'
 
 module Mongoid
@@ -12,6 +13,7 @@ module Mongoid
         class Enumerable
           extend Forwardable
           include ::Enumerable
+          include FieldReadable
           include Pluckable
 
           # The three main instance variables are collections of documents.
@@ -590,7 +592,7 @@ module Mongoid
           #
           # @return [ Array<Numeric> ] The non-nil field values.
           def field_values_for(field)
-            map { |doc| doc.public_send(field) }.compact
+            map { |doc| read_field_value(doc, field) }.compact
           end
 
           def set_base(document)

data/lib/mongoid/association/referenced/has_many/proxy.rb

@@ -538,12 +538,111 @@ module Mongoid
           # @return [ Integer ] The number of documents deleted.
           def remove_all(conditions = nil, method = :delete_all)
             selector = conditions || {}
-            removed = klass.send(method, selector.merge!(criteria.selector))
+            selector.merge!(criteria.selector)
+
+            # Scanning before the delete means scanning only what is already in
+            # memory, so it is only done where there is a pattern whose cost has
+            # to be bounded. Everywhere else the delete comes first and the scan
+            # sees the survivors, which is what this association has always
+            # done.
+            #
+            # The limit is read once and carried into whichever branch is taken.
+            # Letting the branch below ask again would read it a second time,
+            # across a server round trip, and a limit that had become positive
+            # in the meantime would put a deadline on the delete_if -- a query,
+            # and an unbind of every match -- which is the arrangement this
+            # branch exists to avoid.
+            limit = Matcher::RegexpBudget.limit_for(selector)
+            return remove_all_bounded(selector, method, limit) if limit
+
+            removed = klass.send(method, selector)
+
+            # No scope around this. The scan runs after the delete, so the
+            # association this loads comes back holding only what the delete did
+            # not match, and there is no pattern here to bound in any case.
+            # Opening a scope would save _matches? from deciding once per
+            # document -- 0.48us against 1.74us for the match itself -- but a
+            # scope with nothing to bound suppresses that decision for
+            # everything nested inside it, and loading the association runs
+            # find callbacks. A pattern in a selector one of those evaluates
+            # would go unguarded, which costs more than the saving is worth on a
+            # path that has just made two round trips.
             _target.delete_if do |doc|
               doc._matches?(selector).tap do |b|
                 unbind_one(doc) if b
               end
             end
+
+            removed
+          end
+
+          # Deletes all related documents matching a selector that carries a
+          # regular expression, with the whole scan under one regexp budget.
+          #
+          # The scan runs before anything is deleted, so a budget that runs out
+          # leaves both the database and the association untouched rather than
+          # reporting a failure for a delete that has already happened. It also
+          # means the budget is closed by the time the association is mutated,
+          # so where the budget is enforced with Timeout there is no window for
+          # the exception to land in the middle of an unbind.
+          #
+          # @param [ Hash ] selector The selector to delete with.
+          # @param [ Symbol ] method The deletion method to call.
+          # @param [ Float ] limit The seconds the scan may spend, as read by
+          #   the caller when it chose this path.
+          #
+          # @return [ Integer ] The number of documents deleted.
+          def remove_all_bounded(selector, method, limit)
+            # Only what the association already holds. Iterating it instead
+            # would load the whole association before the delete, and for a
+            # broad pattern that is every document the association has: /.*/ is
+            # both the cheapest pattern an attacker can supply and the one that
+            # matches everything, so bounding the cost of the matching would
+            # have been paid for with an unbounded amount of memory. Nothing is
+            # missed by not loading, because the server evaluates the same
+            # selector for the delete itself.
+            #
+            # It also means the scan runs no query, so no deadline of ours can
+            # land on one. Where the budget is enforced with Timeout, covering
+            # a query would report a slow network as a regexp timeout and could
+            # deliver the asynchronous exception inside the driver's socket
+            # read.
+            documents = _target.in_memory
+
+            matching = Matcher::RegexpBudget.open_with(limit) do
+              documents.select { |doc| doc._matches?(selector) }
+            end
+
+            removed = klass.send(method, selector)
+
+            # The ids are already known to be in memory, so the loaded and added
+            # documents can be dropped directly. Enumerable#delete would look
+            # each one up by id and stop at the first hash that has it, which
+            # removes the wrong instance when both hashes hold one for the same
+            # id. Enumerable#delete_if drops it from both, as this does, but
+            # only after load_all!, which is the load this scan exists to avoid.
+            #
+            # Which documents get unbound has always depended on which ones
+            # happened to be in memory, and scanning only what is in memory
+            # keeps that. It matters for has_and_belongs_to_many, whose
+            # unbind_one pulls the id out of the foreign key array on _base and
+            # marks it dirty; the scan used to run after the delete, against an
+            # association that a cold proxy had just reloaded as holding only
+            # the survivors, so nothing matched and nothing was unbound.
+            #
+            # TODO: unbinding should not depend on what was in memory. Every
+            # matched document leaves the association, so every one of them
+            # should be unbound, which would also stop _base's foreign key
+            # array from keeping ids that no longer resolve. That is a
+            # behaviour change for has_and_belongs_to_many and belongs in a
+            # ticket of its own, with a release note; it should not ride along
+            # on this one.
+            matching.each do |doc|
+              unbind_one(doc)
+              _target._loaded.delete(doc._id)
+              _target._added.delete(doc._id)
+            end
+
             removed
           end
 

data/lib/mongoid/association/referenced/has_many_through/eager.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasManyThrough
+        # Two-query eager preloader for has_many :through associations.
+        class Eager < Association::Eager
+          private
+
+          def preload
+            @docs.each { |d| set_relation(d, []) }
+
+            through_assoc = @association.through_association
+            source_assoc  = @association.source_association
+
+            owner_pk   = through_assoc.primary_key
+            through_fk = through_assoc.foreign_key
+
+            owner_ids = @docs.filter_map { |d| d.public_send(owner_pk) }.uniq
+            return if owner_ids.empty?
+
+            # Step 1: load all intermediate records
+            intermediates = through_assoc.klass
+                                         .where(through_fk => { '$in' => owner_ids })
+                                         .to_a
+
+            # Step 2: map owner FK values to arrays of target docs
+            targets_by_owner_fk = build_targets_map(intermediates, through_fk, source_assoc)
+
+            # Step 3: set relation on each owner doc
+            @docs.each do |doc|
+              key_val = doc.public_send(owner_pk)
+              set_relation(doc, targets_by_owner_fk[key_val] || [])
+            end
+          end
+
+          # Build a Hash mapping each owner FK value to an array of target docs.
+          # Uses two different strategies depending on where the FK lives.
+          def build_targets_map(intermediates, through_fk, source_assoc)
+            if source_assoc.stores_foreign_key?
+              fk_on_intermediate_targets_map(intermediates, through_fk, source_assoc)
+            else
+              fk_on_source_targets_map(intermediates, through_fk, source_assoc)
+            end
+          end
+
+          # FK is on the intermediate (e.g. appointment.patient_id -> belongs_to :patient).
+          def fk_on_intermediate_targets_map(intermediates, through_fk, source_assoc)
+            source_fk_vals = intermediates.filter_map { |i| i.public_send(source_assoc.foreign_key) }.uniq
+            targets = source_assoc.klass.where(
+              source_assoc.primary_key => { '$in' => source_fk_vals }
+            ).to_a
+            targets_by_pk = targets.group_by { |t| t.public_send(source_assoc.primary_key) }
+
+            result = Hash.new { |h, k| h[k] = [] }
+            intermediates.each do |i|
+              owner_fk_val = i.public_send(through_fk)
+              matched = targets_by_pk[i.public_send(source_assoc.foreign_key)] || []
+              result[owner_fk_val].concat(matched)
+            end
+            result
+          end
+
+          # FK is on the source (e.g. reader.book_id -> has_many :readers on Book).
+          def fk_on_source_targets_map(intermediates, through_fk, source_assoc)
+            source_pk = source_assoc.primary_key
+            intermediate_pks = intermediates.filter_map { |i| i.public_send(source_pk) }.uniq
+            targets = source_assoc.klass.where(
+              source_assoc.foreign_key => { '$in' => intermediate_pks }
+            ).to_a
+            targets_by_source_fk = targets.group_by { |t| t.public_send(source_assoc.foreign_key) }
+
+            result = Hash.new { |h, k| h[k] = [] }
+            intermediates.each do |i|
+              owner_fk_val = i.public_send(through_fk)
+              matched = targets_by_source_fk[i.public_send(source_pk)] || []
+              result[owner_fk_val].concat(matched)
+            end
+            result
+          end
+
+          def set_relation(doc, element)
+            return if doc.blank?
+
+            proxy = HasManyThrough::Proxy.new(doc, @association, preloaded: element)
+            doc.set_relation(@association.name, proxy)
+          end
+
+          # Required by base class contract. Not called from preload since this
+          # class manages its own two-query traversal directly.
+          def group_by_key
+            @association.through_association.primary_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced/has_many_through/proxy.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasManyThrough
+        # Read-only proxy for has_many :through associations. Wraps the lazy
+        # Criteria returned by the association and raises ReadonlyAssociation on
+        # any write attempt.
+        class Proxy
+          extend Forwardable
+          include Enumerable
+
+          module ClassMethods
+            def eager_loader(association, docs)
+              Eager.new(association, docs)
+            end
+
+            def embedded?
+              false
+            end
+          end
+
+          extend ClassMethods
+
+          # Enumerable methods use the preloaded array when available; query
+          # methods always delegate to criteria so callers get a Criteria back.
+          def_delegators :_source,
+                         :each, :to_a, :first, :last, :count, :size, :length,
+                         :exists?, :any?, :none?, :empty?
+
+          def_delegators :criteria,
+                         :where, :pluck, :limit, :skip, :order_by, :only, :without,
+                         :sum, :avg, :min, :max
+
+          READONLY_METHODS = %i[
+            << push concat substitute build new create create!
+            delete delete_one delete_all destroy_all clear nullify
+          ].freeze
+
+          def initialize(base, association, preloaded: nil)
+            @_base        = base
+            @_association = association
+            @preloaded    = preloaded
+          end
+
+          def criteria
+            @criteria ||= @_association.criteria(@_base)
+          end
+
+          private
+
+          def _source
+            @preloaded || criteria
+          end
+
+          public
+
+          READONLY_METHODS.each do |meth|
+            define_method(meth) do |*|
+              raise Mongoid::Errors::ReadonlyAssociation.new(@_base.class, @_association)
+            end
+          end
+        end
+      end
+    end
+  end
+end