mongoid 9.1.1 → 9.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bfb9894822f364261e1579143e0a4860a27dfe42437243938ecb2bc186a0819
-  data.tar.gz: f66924e8684458b2318f82bc7614f01823938e8c7cb3f19bf5246dd1098dd5b5
+  metadata.gz: 0f94dec89da2023d081f5c08eed8a5ee4f61fd511b7f8eaea3dd8afde665829d
+  data.tar.gz: cb6e13ef1c7e708620d747a31f4cfff15088bd451c41259c2ade7b9bf4b26bdb
 SHA512:
-  metadata.gz: 16d064d36b9a6a425d2727afdb879da7a28dd25a5889de7dd6242120d69441fb666db16dec584b0e00c77aed32fcd0a5d900c7fc3ed8ddfe0fe2006b0053dbc2
-  data.tar.gz: 2d8c367c96724961cdd78354a8bf6d10cef2fa209cec4103741e26d43389286a173a8df301116121b2e9ad89495c7c5e268b4458dd8b22e6a2ddb4fbdd835eb0
+  metadata.gz: e4695df34902c08d6c0bb8f95f9e128f0a154b5a859b3e97181646cb6cd9f24a2d138be0721c2bba761e1db5327d7b207ce104c8d6edad1b9336f6dc62aa2e39
+  data.tar.gz: 99cb2aa72fcdf82ecd8f43d2a5bae06113a1af687d1e01d7a54f12e6b996c517c817b7b9b72c0418ddbd8e09af6e692159852cf8acafa3166166db5174acf34d

data/lib/config/locales/en.yml

@@ -239,6 +239,13 @@ en:
             Mongoid does not support."
           resolution: "Valid field operators are: %{valid_operators}.
             Ensure you are using one of these operators."
+        invalid_encryption_schema:
+          message: "The encryption schema for %{namespace} is invalid."
+          summary: "Two models writing to %{namespace} describe %{path}
+            differently. The encryption schema has one entry per namespace,
+            so the two descriptions cannot both be used."
+          resolution: "Make the models agree on the encryption options of the
+            conflicting field, or store them in different collections."
         invalid_estimated_count_criteria:
           message: "Invalid criteria for estimated_count."
           summary: "Estimated count is strictly a collection-level operation and cannot be called
@@ -544,22 +551,35 @@ en:
         no_encryption_schema:
           message: "The encryption schema of client %{client} does not cover
             %{namespace}."
-          summary: "%{klass} declares encrypted fields, but the namespace it
-            resolved to, %{namespace}, is not part of the automatic encryption
-            schema of client %{client}. The encryption schema is built once,
-            when the client is created, and is keyed by namespace, so a
-            database name that is only known later - a callable :database
-            option, Model.with(database:), Mongoid.override_database - is not
-            in it. Routing the model to a client that has no
-            auto_encryption_options has the same effect. Mongoid refuses the
-            operation because the driver would store the declared fields in
-            plaintext without reporting an error."
+          summary: "%{klass} declares encrypted fields, directly or through
+            an embedded model, but the namespace it resolved to, %{namespace},
+            is not part of the automatic encryption schema of client
+            %{client}. The encryption schema is built once, when the client
+            is created, and is keyed by namespace, so a database name that is
+            only known later - a callable :database option,
+            Model.with(database:), Mongoid.override_database - is not in it.
+            The same happens when an embedded model with encrypted fields was
+            not yet loaded when the client was created. Routing the model to a
+            client that has no auto_encryption_options has the same effect.
+            Mongoid refuses the operation because the driver would store the
+            declared fields in plaintext without reporting an error."
           resolution: "Give the model a namespace that is known when the
             client is created, and a client configured with
-            auto_encryption_options. If the model has to live in a database
+            auto_encryption_options. Load all models, including embedded
+            ones, before the first client is created, for example by
+            preloading them at boot. If the model has to live in a database
             chosen at runtime, configure one client per database, each with
             its own auto_encryption_options, and select between them with
             Model.with(client:) instead of switching the database."
+        no_encryption_schema_field:
+          message: "The encryption schema of client %{client} does not cover
+            the field %{field} of %{namespace}."
+          summary: "The namespace %{namespace} is in the automatic encryption
+            schema of client %{client}, but its entry does not encrypt
+            %{field}, which %{klass} declares as encrypted. Mongoid refuses
+            the operation rather than storing the field in plaintext."
+          resolution: "Regenerate the schema map of the client, or add
+            %{field} to the schema entry for %{namespace}."
         no_map_reduce_output:
           message: "No output location was specified for the map/reduce
             operation."

data/lib/mongoid/association/accessors.rb

@@ -86,6 +86,24 @@ module Mongoid
         instance_variable_set("@_#{name}", relation)
       end
 
+      # Loads the documents the query preloaded for this one, kept apart from the
+      # attributes so they are not part of the document. A name this class
+      # doesn't define is dropped: a $lookup writes its field on every document
+      # it returns, including those of a sibling subclass that has no such
+      # association.
+      #
+      # @param [ Hash ] preloaded The preloaded documents by the field they
+      #   travelled in.
+      #
+      # @api private
+      def load_preloaded_associations(preloaded)
+        preloaded.each do |field, documents|
+          name = field.delete_prefix(PRELOADED_PREFIX)
+          association = relations[name]
+          __build__(name, documents, association) if association
+        end
+      end
+
       private
 
       # Get the association. Extracted out from the getter method to avoid
@@ -127,10 +145,6 @@ module Mongoid
             _loading do
               if object && needs_no_database_query?(object, association)
                 __build__(name, object, association)
-              # Check if data was loaded via $lookup aggregation
-              elsif !association.embedded? && attributes.key?(name.to_s)
-                # Use the pre-loaded association data from $lookup
-                __build__(name, attributes[name.to_s], association)
               else
                 selected_fields = _mongoid_filter_selected_fields(association.key)
                 __build__(name, attributes[association.key], association, selected_fields)

data/lib/mongoid/association/eager_load/discriminated_inclusion.rb

@@ -15,15 +15,15 @@ module Mongoid
       # For Machine.eager_load(:widgets), where Lathe#widgets => Cog and
       # Press#widgets => Belt, it emits:
       #
-      #   { '$lookup' => { 'from' => 'cogs',  ..., 'as' => '__eager_load_widgets_Lathe' } },
-      #   { '$lookup' => { 'from' => 'belts', ..., 'as' => '__eager_load_widgets_Press' } },
+      #   { '$lookup' => { 'from' => 'cogs',  ..., 'as' => '__mongoid_eager_loaded_widgets_Lathe' } },
+      #   { '$lookup' => { 'from' => 'belts', ..., 'as' => '__mongoid_eager_loaded_widgets_Press' } },
       #   { '$set' => {
-      #     'widgets' => { '$switch' => { 'branches' => [   # route each document to its
-      #       { 'case' => { '$eq' => [ '$_type', 'Lathe' ] }, 'then' => '$__eager_load_widgets_Lathe' },  # own type's matches
-      #       { 'case' => { '$eq' => [ '$_type', 'Press' ] }, 'then' => '$__eager_load_widgets_Press' }
+      #     '__mongoid_eager_loaded_widgets' => { '$switch' => { 'branches' => [   # route each document to its
+      #       { 'case' => { '$eq' => [ '$_type', 'Lathe' ] }, 'then' => '$__mongoid_eager_loaded_widgets_Lathe' },  # own type's matches
+      #       { 'case' => { '$eq' => [ '$_type', 'Press' ] }, 'then' => '$__mongoid_eager_loaded_widgets_Press' }
       #     ], 'default' => [] } }
       #   } },
-      #   { '$unset' => [ '__eager_load_widgets_Lathe', '__eager_load_widgets_Press' ] }
+      #   { '$unset' => [ '__mongoid_eager_loaded_widgets_Lathe', '__mongoid_eager_loaded_widgets_Press' ] }
       #
       # @api private
       class DiscriminatedInclusion < Inclusion
@@ -56,7 +56,7 @@ module Mongoid
         end
 
         def temporary_field(node)
-          "__eager_load_#{node.association.name}_#{owner(node).discriminator_value}"
+          node.association.temporary_field(owner(node).discriminator_value)
         end
 
         # The $set that fills the association on each document from the temporary
@@ -68,15 +68,15 @@ module Mongoid
               'then' => "$#{field}"
             }
           end
-          { '$set' => { name => { '$switch' => { 'branches' => branches, 'default' => [] } } } }
+          { '$set' => { preloaded_field => { '$switch' => { 'branches' => branches, 'default' => [] } } } }
         end
 
         def owner(node)
           node.association.inverse_class
         end
 
-        def name
-          @nodes.first.association.name.to_s
+        def preloaded_field
+          @nodes.first.association.preloaded_field
         end
 
         def discriminator_key

data/lib/mongoid/association/eager_load/embedded_distributor.rb

@@ -22,15 +22,15 @@ module Mongoid
       #     'from' => 'devices',               # the embedded port, so they are
       #     'localField' => 'port.device_id',  # collected in a temp top-level
       #     'foreignField' => '_id',           # field instead
-      #     'as' => '__eager_load_port_device'
+      #     'as' => '__mongoid_eager_loaded_device_port'
       #   } },
       #   { '$set' => {
-      #     'port' => { '$mergeObjects' => [   # merge a 'device' key onto the port
+      #     'port' => { '$mergeObjects' => [   # merge the devices onto the port
       #       '$port',
-      #       { 'device' => { '$filter' => { ... } } }   # this port's matches
+      #       { '__mongoid_eager_loaded_device' => { '$filter' => { ... } } }   # this port's matches
       #     ] }
       #   } },
-      #   { '$unset' => '__eager_load_port_device' }  # drop the temp field
+      #   { '$unset' => '__mongoid_eager_loaded_device_port' }  # drop the temp field
       #
       # @api private
       class EmbeddedDistributor
@@ -92,7 +92,7 @@ module Mongoid
         end
 
         def temporary_field
-          "__eager_load_#{path.tr('.', '_')}_#{@association.name}"
+          @association.temporary_field(path.tr('.', '_'))
         end
 
         # An embedded collection (embeds_many) is rebuilt with $map so each element
@@ -104,7 +104,7 @@ module Mongoid
           element = many ? "$$#{head.store_as}" : node
           child =
             if rest.empty?
-              { @association.name.to_s => correlated_matches(element) }
+              { @association.preloaded_field => correlated_matches(element) }
             else
               segment = rest.first.store_as
               { segment => distributed_value(rest, "#{element}.#{segment}") }

data/lib/mongoid/association/eager_load/lookup_pipeline.rb

@@ -67,7 +67,7 @@ module Mongoid
             'from' => association.klass.collection.name,
             'localField' => local_field,
             'foreignField' => foreign_field,
-            'as' => association.name.to_s,
+            'as' => association.preloaded_field,
             'pipeline' => sub_pipeline
           } }
         end

data/lib/mongoid/association/eager_loadable.rb

@@ -94,7 +94,14 @@ module Mongoid
           next unless as = assoc_map.delete(klass)
 
           as.each do |assoc|
-            queue << assoc.class_name
+            # The queue is matched against the assoc_map keys, which are
+            # inverse_class_name values (resolved class names). Push the
+            # resolved class name so a class_name such as "::Photo" or a
+            # module-relative "Item" still matches its nested associations.
+            # A truly polymorphic association (a polymorphic belongs_to) has
+            # no single resolvable target class, so fall back to the raw name.
+            target = assoc.try_relation_class
+            queue << (target ? target.name : assoc.class_name)
 
             # If this class is nested in the inclusion tree, only load documents
             # for the association above it. If there is no parent association,

data/lib/mongoid/association/embedded/batchable.rb

@@ -130,13 +130,29 @@ module Mongoid
         #   batchable.add_atomic_sets([{ field: value }])
         #
         # @param [ Array<Hash> ] sets The atomic sets.
+        #
+        # @return [ Array<Hash> | nil ] The atomic sets, or nil if the base
+        #   document is not persisted or is not being assigned.
         def add_atomic_sets(sets)
-          return unless _assigning?
+          # New embedded documents are persisted whole by their parent with a
+          # $set or $push. A delayed update for one of their associations is
+          # redundant whether or not the document is attached to its parent.
+          # Before attachment, its path is relative to the document instead
+          # of the root.
+          return unless _assigning? && _base.persisted?
 
           _base.delayed_atomic_sets[path].try(:clear)
           _base.collect_children.each do |child|
             child.delayed_atomic_sets.clear
           end
+
+          # If the base document is itself inserted wholesale via a $set of
+          # its atomic path, that $set already contains these documents, and
+          # a nested $set under the same path would conflict with it. The
+          # cleanup above has already cleared the delayed sets the assigned
+          # children recorded, so skipping the recording here is safe.
+          return if _base.settable?
+
           _base.delayed_atomic_sets[path] = sets
         end
 

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

@@ -230,7 +230,7 @@ module Mongoid
             # the id is only ever resolved within the association itself.
             id
           else
-            { _id: id, association.foreign_key => parent.id }
+            { _id: id, association.foreign_key => parent.send(association.primary_key) }
           end
         end
       end

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

@@ -20,6 +20,12 @@ module Mongoid
           # @return [ Array<Document> ] The documents.
           def build(_base, object, _type = nil, selected_fields = nil)
             if query?(object)
+              if object.is_a?(Array) && object.empty?
+                # An empty stored key array is not $lookup output. Build a none
+                # criteria so reset, empty?, and size do not query the database.
+                return query_criteria(nil)
+              end
+
               # Handle array of hashes from $lookup aggregation
               if object.is_a?(Array) && object.all? { |o| o.is_a?(Hash) }
                 return object.map do |attrs|

data/lib/mongoid/association/relatable.rb

@@ -217,6 +217,24 @@ module Mongoid
         stores_foreign_key? ? foreign_key : primary_key
       end
 
+      # The field a $lookup writes this association's preloaded documents into.
+      #
+      # @return [ String ] The field.
+      def preloaded_field
+        "#{PRELOADED_PREFIX}#{name}"
+      end
+
+      # A field where the aggregation collects this association's documents
+      # before moving them to where they belong. The qualifier tells it apart
+      # from the other temporary fields of the same association.
+      #
+      # @param [ String ] qualifier What tells this temporary field apart.
+      #
+      # @return [ String ] The field.
+      def temporary_field(qualifier)
+        "#{preloaded_field}_#{qualifier}"
+      end
+
       # The name of the setter on this object for assigning an associated object.
       #
       # @return [ String ] The setter name.

data/lib/mongoid/association.rb

@@ -33,6 +33,14 @@ module Mongoid
     include Macros
     include Reflections
 
+    # Prefixes the field a $lookup writes an association's preloaded documents
+    # into. They travel apart from the document's own fields, so the hydration
+    # can keep them out of the attributes instead of leaving them on the
+    # document, where a later save would persist them.
+    #
+    # @api private
+    PRELOADED_PREFIX = '__mongoid_eager_loaded_'
+
     # Map the macros to their corresponding Association classes.
     #
     # @return [ Hash ] The mapping from macros to their Association class.

data/lib/mongoid/atomic/modifiers.rb

@@ -13,13 +13,9 @@ module Mongoid
       # @param [ Hash ] modifications The add to set modifiers.
       def add_to_set(modifications)
         modifications.each_pair do |field, value|
-          if add_to_sets.has_key?(field)
-            value.each do |val|
-              add_to_sets[field]['$each'].push(val)
-            end
-          else
-            add_to_sets[field] = { '$each' => value }
-          end
+          mods = add_to_set_conflict?(field) ? conflicting_add_to_sets : add_to_sets
+          add_each_operation(mods, field, value)
+          add_to_set_fields[field.split('.', 2)[0]] = field
         end
       end
 
@@ -31,7 +27,8 @@ module Mongoid
       # @param [ Hash ] modifications The pull all modifiers.
       def pull_all(modifications)
         modifications.each_pair do |field, value|
-          add_operation(pull_alls, field, value)
+          mods = pull_all_conflict?(field) ? conflicting_pull_alls : pull_alls
+          add_operation(mods, field, value)
           pull_fields[field.split('.', 2)[0]] = field
         end
       end
@@ -41,6 +38,14 @@ module Mongoid
       # @example Add pull all operations.
       #   modifiers.pull({ "addresses" => { "_id" => { "$in" => [ 1, 2, 3 ]}}})
       #
+      # A $pull is never split out into a separate write. It shifts the
+      # positions of the remaining array elements, and the paths of the other
+      # operations on that array are built for the positions after the $pull.
+      # In a separate write the $pull could run after them, so they would hit
+      # a different element. Kept in the main update, an operation that
+      # conflicts with the $pull is rejected by MongoDB (code 40) without
+      # changing stored data.
+      #
       # @param [ Hash ] modifications The pull all modifiers.
       def pull(modifications)
         modifications.each_pair do |field, value|
@@ -99,6 +104,7 @@ module Mongoid
           else
             unsets.update(field => true)
           end
+          unset_fields[field.split('.', 2)[0]] = field
         end
       end
 
@@ -166,17 +172,28 @@ module Mongoid
       # @return [ true | false ] If this field is a conflict.
       def set_conflict?(field)
         name = field.split('.', 2)[0]
-        pull_fields.has_key?(name) || push_fields.has_key?(name)
+        pull_fields.has_key?(name) || push_fields.has_key?(name) ||
+          add_to_set_fields.has_key?(name)
       end
 
       # Is the operation going to be a conflict for an $unset?
       #
+      # A $push or $addToSet does not shift existing array element positions,
+      # so a conflicting $unset can be safely applied in a separate write
+      # afterwards. A $pull does shift positions, so the $unset is not split
+      # out in that case; the operations stay in the same update and MongoDB
+      # rejects the update (code 40) without changing stored data, rather
+      # than risking the $unset hitting a different element.
+      #
       # @param [ String ] field The field.
       #
       # @return [ true | false ] If this field is a conflict.
       def unset_conflict?(field)
         key = field.split('.', 2)[0]
-        set_fields.has_key?(key)
+        return true if set_fields.has_key?(key)
+        return false if pull_fields.has_key?(key)
+
+        push_fields.has_key?(key) || add_to_set_fields.has_key?(key)
       end
 
       # Is the operation going to be a conflict for a $push?
@@ -190,9 +207,36 @@ module Mongoid
       def push_conflict?(field)
         name = field.split('.', 2)[0]
         set_fields.has_key?(name) || pull_fields.has_key?(name) ||
+          add_to_set_fields.has_key?(name) || unset_fields.has_key?(name) ||
           (push_fields.keys.count { |item| item.split('.', 2).first == name } > 1)
       end
 
+      # Is the operation going to be a conflict for an $addToSet?
+      #
+      # As with $push, an $addToSet is only split out when the other
+      # operation does not shift array element positions. A conflicting
+      # $pull is left as-is so MongoDB rejects the update rather than the
+      # $addToSet possibly hitting a different element in a separate write.
+      #
+      # @param [ String ] field The field.
+      #
+      # @return [ true | false ] If this field is a conflict.
+      def add_to_set_conflict?(field)
+        name = field.split('.', 2)[0]
+        set_fields.has_key?(name) || push_fields.has_key?(name)
+      end
+
+      # Is the operation going to be a conflict for a $pullAll?
+      #
+      # @param [ String ] field The field.
+      #
+      # @return [ true | false ] If this field is a conflict.
+      def pull_all_conflict?(field)
+        name = field.split('.', 2)[0]
+        set_fields.has_key?(name) || push_fields.has_key?(name) ||
+          add_to_set_fields.has_key?(name) || pull_root?(name)
+      end
+
       # Returns true if the $unset is made redundant by a $set that covers
       # the entire root-level field. When $set "children" is issued, the
       # current (live) state of the array already includes all pending changes
@@ -202,16 +246,26 @@ module Mongoid
       # @param [ String ] field the field
       def unset_superseded_by_set?(field)
         key = field.split('.', 2).first
-        sets(initialize: false).has_key?(key)
+        sets(initialize: false)&.has_key?(key)
+      end
+
+      # Get the conflicting $addToSet operations.
+      #
+      # @example Get the conflicting add to sets.
+      #   modifiers.conflicting_add_to_sets
+      #
+      # @return [ Hash ] The conflicting add to set operations.
+      def conflicting_add_to_sets
+        conflicts['$addToSet'] ||= {}
       end
 
-      # Get the conflicting pull modifications.
+      # Get the conflicting pull all modifications.
       #
-      # @example Get the conflicting pulls.
-      #   modifiers.conflicting_pulls
+      # @example Get the conflicting pull alls.
+      #   modifiers.conflicting_pull_alls
       #
-      # @return [ Hash ] The conflicting pull operations.
-      def conflicting_pulls
+      # @return [ Hash ] The conflicting pull all operations.
+      def conflicting_pull_alls
         conflicts['$pullAll'] ||= {}
       end
 
@@ -282,6 +336,26 @@ module Mongoid
         @set_fields ||= {}
       end
 
+      # Get the names of the fields that need to be added to sets.
+      #
+      # @example Get the add to set fields.
+      #   modifiers.add_to_set_fields
+      #
+      # @return [ Array<String> ] The add to set fields.
+      def add_to_set_fields
+        @add_to_set_fields ||= {}
+      end
+
+      # Get the names of the fields that need to be unset.
+      #
+      # @example Get the unset fields.
+      #   modifiers.unset_fields
+      #
+      # @return [ Array<String> ] The unset fields.
+      def unset_fields
+        @unset_fields ||= {}
+      end
+
       # Get the $pullAll operations or initialize a new one.
       #
       # @example Get the $pullAll operations.
@@ -333,6 +407,16 @@ module Mongoid
       def unsets
         self['$unset'] ||= {}
       end
+
+      # Is there a $pull on the given root-level field? Does not initialize
+      # the $pull operations.
+      #
+      # @param [ String ] name The root-level field name.
+      #
+      # @return [ true | false ] If a $pull touches this field.
+      def pull_root?(name)
+        (self['$pull'] || {}).keys.any? { |key| key.split('.', 2)[0] == name }
+      end
     end
   end
 end

data/lib/mongoid/clients/factory.rb

@@ -90,6 +90,8 @@ module Mongoid
         return nil unless opts[:auto_encryption_options]
 
         opts[:auto_encryption_options].dup.tap do |auto_encryption_options|
+          Mongoid::Warnings.warn_bypass_auto_encryption if auto_encryption_options[:bypass_auto_encryption]
+
           if auto_encryption_options.key?(:schema_map)
             default_logger.warn(
               'The :schema_map is configured in the :auto_encryption_options for the client;' +