mongoid 9.0.11 → 9.1.1

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

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   class Criteria
     module Queryable
-
       # An queryable selectable is selectable, in that it has the ability to select
       # document from the database. The selectable module brings all functionality
       # to the selectable that has to do with building MongoDB selectors.
@@ -12,13 +10,13 @@ module Mongoid
         extend Macroable
 
         # Constant for a LineString $geometry.
-        LINE_STRING = "LineString"
+        LINE_STRING = 'LineString'
 
         # Constant for a Point $geometry.
-        POINT = "Point"
+        POINT = 'Point'
 
         # Constant for a Polygon $geometry.
-        POLYGON = "Polygon"
+        POLYGON = 'Polygon'
 
         # @attribute [rw] negating If the next expression is negated.
         # @attribute [rw] selector The query selector.
@@ -43,27 +41,23 @@ module Mongoid
           end
 
           criteria.inject(clone) do |query, condition|
-            if condition.nil?
-              raise Errors::CriteriaArgumentRequired, :all
-            end
+            raise Errors::CriteriaArgumentRequired, :all if condition.nil?
 
             condition = expand_condition_to_array_values(condition)
 
             if strategy
-              send(strategy, condition, "$all")
+              send(strategy, condition, '$all')
             else
               condition.inject(query) do |_query, (field, value)|
-                v = {'$all' => value}
-                if negating?
-                  v = {'$not' => v}
-                end
+                v = { '$all' => value }
+                v = { '$not' => v } if negating?
                 _query.add_field_expression(field.to_s, v)
               end
             end
           end.reset_strategies!
         end
-        alias :all_in :all
-        key :all, :union, "$all"
+        alias all_in all
+        key :all, :union, '$all'
 
         # Add the $and criterion.
         #
@@ -76,10 +70,8 @@ module Mongoid
         #
         # @return [ Selectable ] The new selectable.
         def and(*criteria)
-          _mongoid_flatten_arrays(criteria).inject(self.clone) do |c, new_s|
-            if new_s.is_a?(Selectable)
-              new_s = new_s.selector
-            end
+          _mongoid_flatten_arrays(criteria).inject(clone) do |c, new_s|
+            new_s = new_s.selector if new_s.is_a?(Selectable)
             normalized = _mongoid_expand_keys(new_s)
             normalized.each do |k, v|
               k = k.to_s
@@ -90,16 +82,15 @@ module Mongoid
                 # we can add to existing conditions.
                 # Otherwise use $and.
                 if v.is_a?(Hash) &&
-                  v.length == 1 &&
-                  (new_k = v.keys.first).start_with?('$') &&
-                  (existing_kv = c.selector[k]).is_a?(Hash) &&
-                  !existing_kv.key?(new_k) &&
-                  existing_kv.keys.all? { |sub_k| sub_k.start_with?('$') }
-                then
+                   v.length == 1 &&
+                   (new_k = v.keys.first).start_with?('$') &&
+                   (existing_kv = c.selector[k]).is_a?(Hash) &&
+                   !existing_kv.key?(new_k) &&
+                   existing_kv.keys.all? { |sub_k| sub_k.start_with?('$') }
                   merged_v = c.selector[k].merge(v)
                   c.selector.store(k, merged_v)
                 else
-                  c = c.send(:__multi__, [k => v], '$and')
+                  c = c.send(:__multi__, [ { k => v } ], '$and')
                 end
               else
                 c.selector.store(k, v)
@@ -108,7 +99,7 @@ module Mongoid
             c
           end
         end
-        alias :all_of :and
+        alias all_of and
 
         # Add the range selection.
         #
@@ -122,14 +113,12 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def between(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :between
-          end
+          raise Errors::CriteriaArgumentRequired, :between if criterion.nil?
 
           selection(criterion) do |selector, field, value|
             selector.store(
               field,
-              { "$gte" => value.min, "$lte" => value.max }
+              { '$gte' => value.min, '$lte' => value.max }
             )
           end
         end
@@ -152,13 +141,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def elem_match(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :elem_match
-          end
+          raise Errors::CriteriaArgumentRequired, :elem_match if criterion.nil?
 
-          and_with_operator(criterion, "$elemMatch")
+          and_with_operator(criterion, '$elemMatch')
         end
-        key :elem_match, :override, "$elemMatch"
+        key :elem_match, :override, '$elemMatch'
 
         # Add the $exists selection.
         #
@@ -175,15 +162,13 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def exists(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :exists
-          end
+          raise Errors::CriteriaArgumentRequired, :exists if criterion.nil?
 
-          typed_override(criterion, "$exists") do |value|
+          typed_override(criterion, '$exists') do |value|
             Mongoid::Boolean.evolve(value)
           end
         end
-        key :exists, :override, "$exists" do |value|
+        key :exists, :override, '$exists' do |value|
           Mongoid::Boolean.evolve(value)
         end
 
@@ -222,26 +207,24 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def geo_spatial(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :geo_spatial
-          end
+          raise Errors::CriteriaArgumentRequired, :geo_spatial if criterion.nil?
 
           __merge__(criterion)
         end
 
-        key :intersects_line, :override, "$geoIntersects", "$geometry" do |value|
-          { "type" => LINE_STRING, "coordinates" => value }
+        key :intersects_line, :override, '$geoIntersects', '$geometry' do |value|
+          { 'type' => LINE_STRING, 'coordinates' => value }
         end
-        key :intersects_point, :override, "$geoIntersects", "$geometry" do |value|
-          { "type" => POINT, "coordinates" => value }
+        key :intersects_point, :override, '$geoIntersects', '$geometry' do |value|
+          { 'type' => POINT, 'coordinates' => value }
         end
-        key :intersects_polygon, :override, "$geoIntersects", "$geometry" do |value|
-          { "type" => POLYGON, "coordinates" => value }
+        key :intersects_polygon, :override, '$geoIntersects', '$geometry' do |value|
+          { 'type' => POLYGON, 'coordinates' => value }
         end
-        key :within_polygon, :override, "$geoWithin", "$geometry" do |value|
-          { "type" => POLYGON, "coordinates" => value }
+        key :within_polygon, :override, '$geoWithin', '$geometry' do |value|
+          { 'type' => POLYGON, 'coordinates' => value }
         end
-        key :within_box, :override, "$geoWithin", "$box"
+        key :within_box, :override, '$geoWithin', '$box'
 
         # Add the $eq criterion to the selector.
         #
@@ -255,13 +238,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def eq(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :eq
-          end
+          raise Errors::CriteriaArgumentRequired, :eq if criterion.nil?
 
-          and_with_operator(criterion, "$eq")
+          and_with_operator(criterion, '$eq')
         end
-        key :eq, :override, "$eq"
+        key :eq, :override, '$eq'
 
         # Add the $gt criterion to the selector.
         #
@@ -275,13 +256,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def gt(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :gt
-          end
+          raise Errors::CriteriaArgumentRequired, :gt if criterion.nil?
 
-          and_with_operator(criterion, "$gt")
+          and_with_operator(criterion, '$gt')
         end
-        key :gt, :override, "$gt"
+        key :gt, :override, '$gt'
 
         # Add the $gte criterion to the selector.
         #
@@ -295,13 +274,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def gte(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :gte
-          end
+          raise Errors::CriteriaArgumentRequired, :gte if criterion.nil?
 
-          and_with_operator(criterion, "$gte")
+          and_with_operator(criterion, '$gte')
         end
-        key :gte, :override, "$gte"
+        key :gte, :override, '$gte'
 
         # Adds the $in selection to the selectable.
         #
@@ -318,26 +295,22 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def in(condition)
-          if condition.nil?
-            raise Errors::CriteriaArgumentRequired, :in
-          end
+          raise Errors::CriteriaArgumentRequired, :in if condition.nil?
 
           condition = expand_condition_to_array_values(condition)
 
           if strategy
-            send(strategy, condition, "$in")
+            send(strategy, condition, '$in')
           else
             condition.inject(clone) do |query, (field, value)|
-              v = {'$in' => value}
-              if negating?
-                v = {'$not' => v}
-              end
+              v = { '$in' => value }
+              v = { '$not' => v } if negating?
               query.add_field_expression(field.to_s, v)
             end.reset_strategies!
           end
         end
-        alias :any_in :in
-        key :in, :intersect, "$in"
+        alias any_in in
+        key :in, :intersect, '$in'
 
         # Add the $lt criterion to the selector.
         #
@@ -351,13 +324,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def lt(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :lt
-          end
+          raise Errors::CriteriaArgumentRequired, :lt if criterion.nil?
 
-          and_with_operator(criterion, "$lt")
+          and_with_operator(criterion, '$lt')
         end
-        key :lt, :override, "$lt"
+        key :lt, :override, '$lt'
 
         # Add the $lte criterion to the selector.
         #
@@ -371,13 +342,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def lte(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :lte
-          end
+          raise Errors::CriteriaArgumentRequired, :lte if criterion.nil?
 
-          and_with_operator(criterion, "$lte")
+          and_with_operator(criterion, '$lte')
         end
-        key :lte, :override, "$lte"
+        key :lte, :override, '$lte'
 
         # Add a $maxDistance selection to the selectable.
         #
@@ -388,12 +357,10 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def max_distance(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :max_distance
-          end
+          raise Errors::CriteriaArgumentRequired, :max_distance if criterion.nil?
 
           # $maxDistance must be given together with $near
-          __add__(criterion, "$maxDistance")
+          __add__(criterion, '$maxDistance')
         end
 
         # Adds $mod selection to the selectable.
@@ -408,13 +375,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def mod(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :mod
-          end
+          raise Errors::CriteriaArgumentRequired, :mod if criterion.nil?
 
-          and_with_operator(criterion, "$mod")
+          and_with_operator(criterion, '$mod')
         end
-        key :mod, :override, "$mod"
+        key :mod, :override, '$mod'
 
         # Adds $ne selection to the selectable.
         #
@@ -428,14 +393,12 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def ne(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :ne
-          end
+          raise Errors::CriteriaArgumentRequired, :ne if criterion.nil?
 
-          and_with_operator(criterion, "$ne")
+          and_with_operator(criterion, '$ne')
         end
-        alias :excludes :ne
-        key :ne, :override, "$ne"
+        alias excludes ne
+        key :ne, :override, '$ne'
 
         # Adds a $near criterion to a geo selection.
         #
@@ -449,13 +412,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def near(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :near
-          end
+          raise Errors::CriteriaArgumentRequired, :near if criterion.nil?
 
-          and_with_operator(criterion, "$near")
+          and_with_operator(criterion, '$near')
         end
-        key :near, :override, "$near"
+        key :near, :override, '$near'
 
         # Adds a $nearSphere criterion to a geo selection.
         #
@@ -469,13 +430,11 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def near_sphere(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :near_sphere
-          end
+          raise Errors::CriteriaArgumentRequired, :near_sphere if criterion.nil?
 
-          and_with_operator(criterion, "$nearSphere")
+          and_with_operator(criterion, '$nearSphere')
         end
-        key :near_sphere, :override, "$nearSphere"
+        key :near_sphere, :override, '$nearSphere'
 
         # Adds the $nin selection to the selectable.
         #
@@ -492,26 +451,22 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def nin(condition)
-          if condition.nil?
-            raise Errors::CriteriaArgumentRequired, :nin
-          end
+          raise Errors::CriteriaArgumentRequired, :nin if condition.nil?
 
           condition = expand_condition_to_array_values(condition)
 
           if strategy
-            send(strategy, condition, "$nin")
+            send(strategy, condition, '$nin')
           else
             condition.inject(clone) do |query, (field, value)|
-              v = {'$nin' => value}
-              if negating?
-                v = {'$not' => v}
-              end
+              v = { '$nin' => value }
+              v = { '$not' => v } if negating?
               query.add_field_expression(field.to_s, v)
             end.reset_strategies!
           end
         end
-        alias :not_in :nin
-        key :nin, :intersect, "$nin"
+        alias not_in nin
+        key :nin, :intersect, '$nin'
 
         # Adds $nor selection to the selectable.
         #
@@ -536,16 +491,16 @@ module Mongoid
           !!negating
         end
 
-        # Negate the arguments, or the next selection if no arguments are given.
-        #
-        # @example Negate the next selection.
-        #   selectable.not.in(field: [ 1, 2 ])
+        # Negate the arguments.
         #
         # @example Add the $not criterion.
-        #   selectable.not(name: /Bob/)
+        #   Person.not(name: /Bob/)
         #
         # @example Execute a $not in a where query.
-        #   selectable.where(:field.not => /Bob/)
+        #   Person.where(:name.not => /Bob/)
+        #
+        # @example Negate a Criteria instance
+        #   Person.not(Person.where(...))
         #
         # @param [ [ Hash | Criteria ]... ] *criteria The key/value pair
         #   matches or Criteria objects to negate.
@@ -553,34 +508,38 @@ module Mongoid
         # @return [ Selectable ] The new selectable.
         def not(*criteria)
           if criteria.empty?
+            # @deprecated
+            Mongoid.deprecation_warning(
+              :not_sans_arguments,
+              'Calling `#not` without arguments is deprecated, and will be ' \
+              'removed in the next major version. Instead, pass the Hash or ' \
+              'Criteria instance to negate.',
+              caller_locations
+            )
             dup.tap { |query| query.negating = !query.negating }
           else
-            criteria.compact.inject(self.clone) do |c, new_s|
-              if new_s.is_a?(Selectable)
-                new_s = new_s.selector
-              end
+            criteria.compact.inject(clone) do |c, new_s|
+              new_s = new_s.selector if new_s.is_a?(Selectable)
               _mongoid_expand_keys(new_s).each do |k, v|
                 k = k.to_s
                 if c.selector[k] || k.start_with?('$')
-                  c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
+                  c = c.send(:__multi__, [ { '$nor' => [ { k => v } ] } ], '$and')
+                elsif v.is_a?(Hash)
+                  c = c.send(:__multi__, [ { '$nor' => [ { k => v } ] } ], '$and')
                 else
-                  if v.is_a?(Hash)
-                    c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
-                  else
-                    if v.is_a?(Regexp)
-                      negated_operator = '$not'
-                    else
-                      negated_operator = '$ne'
-                    end
-                    c = c.send(:__override__, {k => v}, negated_operator)
-                  end
+                  negated_operator = if v.is_a?(Regexp)
+                                       '$not'
+                                     else
+                                       '$ne'
+                                     end
+                  c = c.send(:__override__, { k => v }, negated_operator)
                 end
               end
               c
             end
           end
         end
-        key :not, :override, "$not"
+        key :not, :override, '$not'
 
         # Negate the arguments, constraining the query to only those documents
         # that do NOT match the arguments.
@@ -604,8 +563,8 @@ module Mongoid
 
           exprs = criteria.map do |criterion|
             _mongoid_expand_keys(
-                criterion.is_a?(Selectable) ?
-                  criterion.selector : criterion)
+              criterion.is_a?(Selectable) ? criterion.selector : criterion
+            )
           end
 
           self.and('$nor' => exprs)
@@ -690,9 +649,9 @@ module Mongoid
               else
                 Hash[criterion.map do |k, v|
                   if k.is_a?(Symbol)
-                    [k.to_s, v]
+                    [ k.to_s, v ]
                   else
-                    [k, v]
+                    [ k, v ]
                   end
                 end]
               end
@@ -716,15 +675,13 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def with_size(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :with_size
-          end
+          raise Errors::CriteriaArgumentRequired, :with_size if criterion.nil?
 
-          typed_override(criterion, "$size") do |value|
+          typed_override(criterion, '$size') do |value|
             ::Integer.evolve(value)
           end
         end
-        key :with_size, :override, "$size" do |value|
+        key :with_size, :override, '$size' do |value|
           ::Integer.evolve(value)
         end
 
@@ -742,15 +699,13 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def with_type(criterion)
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :with_type
-          end
+          raise Errors::CriteriaArgumentRequired, :with_type if criterion.nil?
 
-          typed_override(criterion, "$type") do |value|
+          typed_override(criterion, '$type') do |value|
             ::Integer.evolve(value)
           end
         end
-        key :with_type, :override, "$type" do |value|
+        key :with_type, :override, '$type' do |value|
           ::Integer.evolve(value)
         end
 
@@ -774,12 +729,10 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def text_search(terms, opts = nil)
-          if terms.nil?
-            raise Errors::CriteriaArgumentRequired, :terms
-          end
+          raise Errors::CriteriaArgumentRequired, :terms if terms.nil?
 
           clone.tap do |query|
-            criterion = {'$text' => { '$search' => terms }}
+            criterion = { '$text' => { '$search' => terms } }
             criterion['$text'].merge!(opts) if opts
             if query.selector['$text']
               # Per https://www.mongodb.com/docs/manual/reference/operator/query/text/
@@ -788,7 +741,7 @@ module Mongoid
               # overwriting previous text search condition with the currently
               # given one.
               Mongoid.logger.warn('Multiple $text expressions per query are not currently supported by the server')
-              query.selector = {'$and' => [query.selector]}.merge(criterion)
+              query.selector = { '$and' => [ query.selector ] }.merge(criterion)
             else
               query.selector = query.selector.merge(criterion)
             end
@@ -810,10 +763,10 @@ module Mongoid
         #
         # @return [ Selectable ] The cloned selectable.
         def where(*criteria)
-          criteria.inject(clone) do |query, criterion|
-            if criterion.nil?
-              raise Errors::CriteriaArgumentRequired, :where
-            end
+          return clone.reset_strategies! if criteria.empty?
+
+          criteria.inject(self) do |query, criterion|
+            raise Errors::CriteriaArgumentRequired, :where if criterion.nil?
 
             # We need to save the criterion in an instance variable so
             # Modifiable methods know how to create a polymorphic object.
@@ -823,14 +776,31 @@ module Mongoid
             # only ever specify one criterion to #where.
             @criterion = criterion
             if criterion.is_a?(String)
-              js_query(criterion)
+              unless Mongoid.allow_unsafe_query_operators?
+                raise Errors::InvalidQuery,
+                      "String criteria are not allowed because they compile to the '$where' operator, " \
+                      'which is not allowed in a query expression. Set Mongoid.allow_unsafe_query_operators = true ' \
+                      'to permit all operators.'
+              end
+              query.js_query(criterion)
             else
-              expr_query(criterion)
+              query.expr_query(criterion)
             end
-          end.reset_strategies!
+          end
         end
 
-        private
+        # Operators permitted at the top level of a query expression without
+        # opt-in. Excludes $where (JS execution) and other operators not needed
+        # for ordinary application queries.
+        ALLOWED_QUERY_OPERATORS = %w[
+          $and $or $nor $not $text $comment $expr $jsonSchema $alwaysFalse $alwaysTrue
+        ].freeze
+
+        # Operators that execute server-side JavaScript. These are rejected at
+        # any depth, not just at the top level: the allowlist above permits
+        # $expr and the logical operators, and their values are arbitrary
+        # nested expressions that can carry $function or $where.
+        JAVASCRIPT_QUERY_OPERATORS = %w[$where $function $accumulator].freeze
 
         # Adds the specified expression to the query.
         #
@@ -850,19 +820,18 @@ module Mongoid
         # @return [ Selectable ] The cloned selectable.
         # @api private
         def expr_query(criterion)
-          if criterion.nil?
-            raise ArgumentError, 'Criterion cannot be nil here'
-          end
-          unless Hash === criterion
+          raise ArgumentError, 'Criterion cannot be nil here' if criterion.nil?
+          unless criterion.is_a?(Hash)
             raise Errors::InvalidQuery, "Expression must be a Hash: #{Errors::InvalidQuery.truncate_expr(criterion)}"
           end
 
+          # The operator guard is applied by _mongoid_expand_keys, which every
+          # query method that accepts a user-supplied expression passes through.
           normalized = _mongoid_expand_keys(criterion)
           clone.tap do |query|
             normalized.each do |field, value|
               field_s = field.to_s
               if field_s.start_with?('$')
-                # Query expression-level operator, like $and or $where
                 query.add_operator_expression(field_s, value)
               else
                 query.add_field_expression(field, value)
@@ -872,25 +841,6 @@ module Mongoid
           end
         end
 
-        # Force the values of the criterion to be evolved.
-        #
-        # @api private
-        #
-        # @example Force values to booleans.
-        #   selectable.force_typing(criterion) do |val|
-        #     Boolean.evolve(val)
-        #   end
-        #
-        # @param [ Hash ] criterion The criterion.
-        def typed_override(criterion, operator)
-          if criterion
-            criterion.transform_values! do |value|
-              yield(value)
-            end
-          end
-          __override__(criterion, operator)
-        end
-
         # Create a javascript selection.
         #
         # @api private
@@ -905,7 +855,7 @@ module Mongoid
           clone.tap do |query|
             if negating?
               query.add_operator_expression('$and',
-                [{'$nor' => [{'$where' => criterion}]}])
+                                            [ { '$nor' => [ { '$where' => criterion } ] } ])
             else
               query.add_operator_expression('$where', criterion)
             end
@@ -913,6 +863,111 @@ module Mongoid
           end
         end
 
+        private
+
+        # Enforces the operator rules governed by the
+        # +allow_unsafe_query_operators+ configuration option against a
+        # normalized query expression.
+        #
+        # Two rules apply, and both are skipped when the option is true:
+        #
+        # - An operator at the top level of the expression must appear in
+        #   ALLOWED_QUERY_OPERATORS.
+        # - An operator in JAVASCRIPT_QUERY_OPERATORS is rejected at any depth.
+        #
+        # This is called from #_mongoid_expand_keys rather than from the
+        # individual query methods, because that is the one point every query
+        # method taking a user-supplied expression passes through on its way to
+        # the selector.
+        #
+        # It deliberately does not cover the APIs that ask for JavaScript
+        # outright, such as #js_query and Criteria#for_js: there the developer
+        # has chosen server-side JavaScript, so there is nothing to guard
+        # against. The same goes for the low-level Storable methods
+        # (#add_field_expression, #add_operator_expression), which write to the
+        # selector directly.
+        #
+        # @param [ Hash ] expr A normalized query expression.
+        #
+        # @raise [ Errors::InvalidQuery ] If a disallowed operator is present.
+        #
+        # @api private
+        def _mongoid_validate_operators!(expr)
+          return if Mongoid.allow_unsafe_query_operators?
+
+          expr.each_key do |field|
+            field_s = field.to_s
+            next unless field_s.start_with?('$')
+            next if ALLOWED_QUERY_OPERATORS.include?(field_s)
+
+            raise Errors::InvalidQuery,
+                  "Operator '#{field_s}' is not allowed in a query expression. " \
+                  'Set Mongoid.allow_unsafe_query_operators = true to permit all operators.'
+          end
+
+          _mongoid_validate_no_javascript!(expr)
+        end
+
+        # Walks a query expression looking for operators that execute
+        # server-side JavaScript, descending through both hashes and arrays so
+        # that nested forms such as {'$expr' => {'$function' => ...}} and
+        # {'$or' => [ {'$where' => ...} ]} are caught.
+        #
+        # The walk does not distinguish operator position from value position,
+        # so it also rejects queries where a JavaScript operator name appears as
+        # data rather than as an operator. Server 5.0+ permits $-prefixed field
+        # names in stored documents, which makes this reachable:
+        #
+        #   Doc.where(payload: { '$eq' => { '$function' => 'abc' } })
+        #
+        # Here the $eq marks its argument as a literal value to compare, so the
+        # server never evaluates it, but the guard raises anyway. The only
+        # workaround today is the global allow_unsafe_query_operators flag.
+        #
+        # TODO: discuss whether to track operator position (skipping the subtree
+        # under $eq, $ne, $in, $nin, and $elemMatch values) in a future
+        # iteration. It removes the false positive but adds exactly the kind of
+        # state that a real bypass could hide in, so it was left out for now.
+        #
+        # @param [ Object ] object A fragment of a query expression.
+        #
+        # @raise [ Errors::InvalidQuery ] If a JavaScript operator is present.
+        #
+        # @api private
+        def _mongoid_validate_no_javascript!(object)
+          case object
+          when Hash
+            object.each do |key, value|
+              key_s = key.to_s
+              if JAVASCRIPT_QUERY_OPERATORS.include?(key_s)
+                raise Errors::InvalidQuery,
+                      "Operator '#{key_s}' executes server-side JavaScript and is not allowed " \
+                      'anywhere in a query expression. Set Mongoid.allow_unsafe_query_operators = true ' \
+                      'to permit all operators.'
+              end
+
+              _mongoid_validate_no_javascript!(value)
+            end
+          when Array
+            object.each { |value| _mongoid_validate_no_javascript!(value) }
+          end
+        end
+
+        # Force the values of the criterion to be evolved.
+        #
+        # @api private
+        #
+        # @example Force values to booleans.
+        #   selectable.force_typing(criterion) do |val|
+        #     Boolean.evolve(val)
+        #   end
+        #
+        # @param [ Hash ] criterion The criterion.
+        def typed_override(criterion, operator, &block)
+          criterion.transform_values!(&block) if criterion
+          __override__(criterion, operator)
+        end
+
         # Take the provided criterion and store it as a selection in the query
         # selector.
         #
@@ -935,7 +990,6 @@ module Mongoid
         end
 
         class << self
-
           # Get the methods on the selectable that can be forwarded to from a model.
           #
           # @example Get the forwardable methods.
@@ -944,7 +998,7 @@ module Mongoid
           # @return [ Array<Symbol> ] The names of the forwardable methods.
           def forwardables
             public_instance_methods(false) -
-              [ :negating, :negating=, :negating?, :selector, :selector= ]
+              %i[negating negating= negating? selector selector=]
           end
         end
       end