parse-stack-next 5.7.0 → 5.7.2

data/lib/parse/query/constraints.rb

@@ -1561,7 +1561,6 @@ module Parse
 
         # if it's a hash, then it should be {:key=>"objectId", :query=>[]}
         remote_field_name = @operation.operand
-        query = nil
         if @value.is_a?(Hash)
           res = @value.symbolize_keys
           remote_field_name = res[:key] || remote_field_name
@@ -1613,7 +1612,6 @@ module Parse
 
         # if it's a hash, then it should be {:key=>"objectId", :query=>[]}
         remote_field_name = @operation.operand
-        query = nil
         if @value.is_a?(Hash)
           res = @value.symbolize_keys
           remote_field_name = res[:key] || remote_field_name
@@ -2263,7 +2261,6 @@ module Parse
       # @return [Hash] the compiled constraint.
       def build
         remote_field_name = @operation.operand
-        query = nil
 
         if @value.is_a?(Hash)
           res = @value.symbolize_keys
@@ -2314,7 +2311,6 @@ module Parse
       # @return [Hash] the compiled constraint.
       def build
         remote_field_name = @operation.operand
-        query = nil
 
         if @value.is_a?(Hash)
           res = @value.symbolize_keys
@@ -2516,6 +2512,19 @@ module Parse
     #  User.where(:name.between => ["Alice", "John"])
     #  # Generates: "name": { "$gte": "Alice", "$lte": "John" }
     #
+    #  # A Ruby Range works the same way as a 2-element array. An inclusive
+    #  # range (`..`) maps its end to $lte, while an exclusive range (`...`)
+    #  # maps its end to $lt.
+    #  User.where(:age.between => 18..65)
+    #  # Generates: "age": { "$gte": 18, "$lte": 65 }
+    #
+    #  Record.where(:date.between => 5.days.ago...2.days.ago)
+    #  # Generates: "date": { "$gte": <5 days ago>, "$lt": <2 days ago> }
+    #
+    #  # Beginless/endless ranges only constrain the side that is present.
+    #  User.where(:age.between => 18..)
+    #  # Generates: "age": { "$gte": 18 }
+    #
     class BetweenConstraint < Constraint
       # @!method between
       # A registered method on a symbol to create the constraint.
@@ -2526,9 +2535,11 @@ module Parse
 
       # @return [Hash] the compiled constraint.
       def build
+        return build_range(@value) if @value.is_a?(Range)
+
         value = formatted_value
         unless value.is_a?(Array) && value.length == 2
-          raise ArgumentError, "#{self.class}: Value must be an array with exactly 2 elements [min_value, max_value]"
+          raise ArgumentError, "#{self.class}: Value must be an array with exactly 2 elements [min_value, max_value], or a Range"
         end
 
         min_value, max_value = value
@@ -2542,6 +2553,51 @@ module Parse
           Parse::Constraint::LessThanOrEqualConstraint.key => formatted_max,
         } }
       end
+
+      # @!visibility private
+      # Extract raw (unformatted) `[min_value, max_value, exclude_max]`
+      # bounds from a `between`-style value: a Range (`exclude_max`
+      # reflects `exclude_end?`) or a 2-element Array (always inclusive
+      # on both ends, matching {#build}'s array branch). Shared with
+      # {Parse::Query#where_not_between}, which needs the same bounds
+      # to build the negated (`$or` of the two flipped comparisons)
+      # form — a shape {BetweenConstraint} itself cannot safely emit
+      # from a single constraint's `#build` (see `where_not_between`'s
+      # docs for why).
+      # @param value [Range, Array] a `between`-style value.
+      # @return [Array(Object, Object, Boolean)]
+      # @raise [ArgumentError] if `value` isn't a Range or 2-element Array.
+      def self.extract_bounds(value)
+        if value.is_a?(Range)
+          [value.begin, value.end, value.exclude_end?]
+        elsif value.is_a?(Array) && value.length == 2
+          [value[0], value[1], false]
+        else
+          raise ArgumentError, "#{name}: Value must be an array with exactly 2 elements [min_value, max_value], or a Range"
+        end
+      end
+
+      private
+
+      # @return [Hash] the compiled constraint for a Ruby Range value.
+      def build_range(range)
+        bounds = {}
+
+        unless range.begin.nil?
+          bounds[Parse::Constraint::GreaterThanOrEqualConstraint.key] = Parse::Constraint.formatted_value(range.begin)
+        end
+
+        unless range.end.nil?
+          upper_key = range.exclude_end? ? Parse::Constraint::LessThanConstraint.key : Parse::Constraint::LessThanOrEqualConstraint.key
+          bounds[upper_key] = Parse::Constraint.formatted_value(range.end)
+        end
+
+        if bounds.empty?
+          raise ArgumentError, "#{self.class}: Range must have a begin, an end, or both (ex. 5.., ..25, 5..25)"
+        end
+
+        { @operation.operand => bounds }
+      end
     end
 
     # @!visibility private

data/lib/parse/query.rb

@@ -1113,6 +1113,77 @@ module Parse
       copy_query
     end
 
+    # Add a "field is NOT between" condition — the logical negation of
+    # `.where(field.between => value)`: `field < min OR field > max` for a
+    # fully-bounded Range/Array, or a single one-sided comparison when the
+    # Range is beginless/endless (mirroring how {Parse::Constraint::BetweenConstraint}
+    # itself only constrains the side that is present).
+    #
+    # Not available as a `field.not_between => value` symbol constraint,
+    # unlike `.between`: a between-style range is inherently an OR of two
+    # comparisons, and a single {Parse::Constraint}'s `#build` can only
+    # safely contribute an AND'd clause to a query. A constraint that
+    # unilaterally emitted a top-level `$or` would collide with (and
+    # silently clobber, or be clobbered by) any other `$or` this query
+    # already produces via {#or_where} / `|` / another `where_not_between`
+    # call, since only one `$or` group merges correctly per query. This
+    # method instead composes the negation the same way {Parse::Query.and}
+    # does — concatenating compiled constraint arrays — which correctly
+    # nests the OR inside the query's existing AND'd conditions instead of
+    # replacing them the way {#or_where} would.
+    #
+    # @example
+    #   Person.query.where_not_between(:age, 5..25)
+    #   # age < 5 OR age > 25
+    #
+    #   Record.query.where(:archived => false).where_not_between(:date, 5.days.ago...2.days.ago)
+    #   # archived == false AND (date < 5.days.ago OR date >= 2.days.ago)
+    #
+    # @param field [Symbol, String] the field to constrain.
+    # @param value [Range, Array] a `between`-style value: a Range (including
+    #   beginless/endless/exclusive-end forms) or a 2-element `[min, max]` Array.
+    # @return [self]
+    # @raise [ArgumentError] if `value` isn't a Range or 2-element Array, or
+    #   is a fully-open (`nil..nil`) Range.
+    def where_not_between(field, value)
+      field = field.to_sym
+      min_value, max_value, exclude_max = Parse::Constraint::BetweenConstraint.extract_bounds(value)
+
+      if min_value.nil? && max_value.nil?
+        raise ArgumentError, "Query#where_not_between: Range must have a begin, an end, or both (ex. 5.., ..25, 5..25)."
+      end
+
+      # A fully-bounded range needs its own `$or` group (`field < min OR
+      # field > max`). Only ONE `$or` group survives the plain-Hash merge
+      # every constraint's compiled output goes through (`constraint_reduce`
+      # deep-merges compiled hashes; a second top-level `$or` key silently
+      # overwrites the first rather than combining with it — the same
+      # constraint that makes `field.not_between => value` unsafe as a
+      # symbol constraint, see above). Fail loudly here instead of quietly
+      # dropping half the query if this query already has one, from
+      # `#or_where`, `|`, or an earlier `where_not_between` call.
+      if min_value && max_value && @where.any? { |c| c.is_a?(Parse::Constraint::CompoundQueryConstraint) }
+        raise ArgumentError,
+              "Query#where_not_between: this query already has an `$or` group (from `or_where`, `|`, " \
+              "or a prior `where_not_between` call). Only one `$or` group can be safely merged per " \
+              "query. Compose the two queries with Parse::Query.and(...) instead."
+      end
+
+      negated = if min_value.nil?
+          Parse::Query.new(@table).where(field.public_send(exclude_max ? :gte : :gt) => max_value)
+        elsif max_value.nil?
+          Parse::Query.new(@table).where(field.lt => min_value)
+        else
+          lower = Parse::Query.new(@table).where(field.lt => min_value)
+          upper = Parse::Query.new(@table).where(field.public_send(exclude_max ? :gte : :gt) => max_value)
+          Parse::Query.or(lower, upper)
+        end
+
+      @where = @where + negated.where
+      @results = nil
+      self
+    end
+
     # Queries can be made using distinct, allowing you find unique values for a specified field.
     # For this to be performant, please remember to index your database.
     # @example
@@ -1409,7 +1480,6 @@ module Parse
         return first_direct(limit_or_constraints)
       end
 
-      fetch_count = 1
       if limit_or_constraints.is_a?(Hash)
         conditions(limit_or_constraints)
         # Check if limit was set in constraints, otherwise use 1
@@ -1490,15 +1560,19 @@ module Parse
     # @return [Parse::Object] the object with the given ID.
     # @raise [Parse::Error] if the object is not found.
     def get(object_id)
-      parse_class = Object.const_get(@table) if Object.const_defined?(@table)
-      parse_class ||= Parse::Object
-
       response = client.fetch_object(@table, object_id)
       if response.error?
         raise Parse::Error.new(response.code, response.error)
       end
 
-      Parse::Object.build(response.result, parse_class)
+      # Pass the table name through as-is rather than pre-resolving it to
+      # a Class: `Object.build` does its own `Parse::Model.find_class`
+      # lookup against the String, which correctly honors `parse_class`
+      # aliasing. Resolving to a Class first and handing that back to
+      # `build` broke aliased lookups, since `find_class` would then
+      # stringify the Ruby constant name (e.g. "Musician") instead of
+      # matching the declared alias (e.g. "Artist").
+      Parse::Object.build(response.result, @table)
     end
 
     # max_results is used to iterate through as many API requests as possible using

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "5.7.0"
+    VERSION = "5.7.2"
   end
 end

data/lib/parse/webhooks.rb

@@ -132,6 +132,46 @@ module Parse
 
     class << self
 
+      # Whether an exception raised by one `after_*` handler prevents the
+      # remaining handlers for that same trigger from running.
+      #
+      # Only the accumulating, non-rejectable `after_*` triggers can have more
+      # than one handler (see {Parse::Webhooks::Registration#route}), so this
+      # governs `after_save`, `after_delete`, and `after_logout` and nothing
+      # else. `before_*` dispatch is untouched: a raise there is how a handler
+      # denies an operation, and it must continue to abort.
+      #
+      # Defaults to `true`, which is the historical behavior. Handlers are
+      # folded with `Array#map`, and `map` abandons the collection on the first
+      # raise, so a handler that raises silently prevents every handler
+      # registered after it from running. That ordering is not something an
+      # application fully controls: the SDK's own cache-invalidation triggers
+      # install during `Parse.setup` and therefore sit ahead of handlers
+      # registered by application files loaded later.
+      #
+      # Set to `false` to isolate handlers from each other, so that each one
+      # runs regardless of what an earlier one raised. The error is reported
+      # (a warning plus a `parse.webhooks.handler_error` notification) and
+      # dispatch continues.
+      #
+      # Either way, nothing is reverted. An `after_*` trigger fires once the
+      # write has already committed, so there is no version of this setting
+      # that can undo the save; the only question it answers is whether the
+      # remaining handlers still get to run.
+      #
+      # @example Keep one failing handler from starving the others
+      #   Parse::Webhooks.abort_after_callbacks_on_error = false
+      #
+      # @return [Boolean]
+      attr_writer :abort_after_callbacks_on_error
+
+      # (see #abort_after_callbacks_on_error=)
+      # @return [Boolean]
+      def abort_after_callbacks_on_error
+        return @abort_after_callbacks_on_error unless @abort_after_callbacks_on_error.nil?
+        true
+      end
+
       # Allows support for web frameworks that support auto-reloading of source.
       # @!visibility private
       def reload!(args = {})
@@ -245,6 +285,60 @@ module Parse
       # block that declares a parameter (`do |payload| ... end`) or a splat
       # receives the payload.
       #
+      # Run every handler registered for one accumulating `after_*` trigger.
+      #
+      # `.last` is preserved as the composed result because Parse Server
+      # ignores the response body for these triggers and {#call_route}
+      # normalizes it anyway, so which handler's value survives is not
+      # observable.
+      #
+      # When {abort_after_callbacks_on_error} is false, a handler that raises
+      # is reported and skipped rather than taking the rest of the trigger down
+      # with it. Nothing is reverted in either mode: the write these triggers
+      # fire on has already committed.
+      #
+      # @param payload [Parse::Webhooks::Payload] the request payload.
+      # @param registry [Array<Proc>] the handlers, in registration order.
+      # @param type [Symbol] the trigger being dispatched.
+      # @return [Object] the last handler result.
+      def dispatch_composed(payload, registry, type)
+        return registry.map { |hook| invoke_handler(payload, hook) }.last if
+          abort_after_callbacks_on_error
+
+        last = nil
+        registry.each do |hook|
+          begin
+            last = invoke_handler(payload, hook)
+          rescue StandardError => e
+            report_handler_error(type, e)
+          end
+        end
+        last
+      end
+
+      # Report a handler failure that was isolated rather than propagated.
+      #
+      # The message is included because an application's own handler raised it
+      # and the application needs it to debug; this is not the SDK's internal
+      # `guard`, which deliberately omits messages that can carry a cache key.
+      #
+      # @param type [Symbol] the trigger being dispatched.
+      # @param error [StandardError] the raised error.
+      # @return [void]
+      def report_handler_error(type, error)
+        warn "[Parse::Webhooks] #{type} handler raised #{error.class}: #{error.message}; " \
+             "continuing with the remaining handlers " \
+             "(Parse::Webhooks.abort_after_callbacks_on_error is false)"
+        return unless defined?(ActiveSupport::Notifications)
+        begin
+          ActiveSupport::Notifications.instrument(
+            "parse.webhooks.handler_error", trigger: type, error: error.class.name,
+          )
+        rescue StandardError
+          nil
+        end
+      end
+
       # @param payload [Parse::Webhooks::Payload] the request payload (becomes `self`).
       # @param block [Proc] the registered handler block.
       # @return [Object] the handler's result value.
@@ -350,7 +444,6 @@ module Parse
           payload.instance_variable_set(:@ruby_initiated, ruby_initiated)
           trusted_ruby_initiated = ruby_initiated && (payload.master? == true)
         else
-          ruby_initiated = false
           trusted_ruby_initiated = false
         end
 
@@ -378,7 +471,10 @@ module Parse
         end
 
         if registry.is_a?(Array)
-          result = registry.map { |hook| invoke_handler(payload, hook) }.last
+          # An Array registry only ever exists for the accumulating,
+          # non-rejectable `after_*` triggers, so isolating handlers here
+          # cannot affect `before_*` rejection semantics.
+          result = dispatch_composed(payload, registry, type)
         else
           result = invoke_handler(payload, registry)
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack-next
 version: !ruby/object:Gem::Version
-  version: 5.7.0
+  version: 5.7.2
 platform: ruby
 authors:
 - Adrian Curtin