parse-stack 1.5.3 → 1.6.0

data/lib/parse/query/ordering.rb

@@ -24,7 +24,7 @@ module Parse
       # @!attribute [rw] field
       # @return [Symbol] the name of the field
       attr_accessor :field
-      
+
       # @!attribute [rw] direction
       # The direction of the sorting. This is either `:asc` or `:desc`.
       # @return [Symbol]
@@ -59,7 +59,7 @@ module Parse
 
 end
 
-# Add all the operator instance methods to the symbol classes
+# Extension to add all the operator instance methods to the Symbol classe
 class Symbol
   Parse::Order::ORDERING.keys.each do |sym|
     define_method(sym) do

data/lib/parse/stack.rb

@@ -9,6 +9,7 @@ require_relative 'webhooks'
 
 
 module Parse
+  class Error < StandardError; end;
   module Stack
 
     # Your code goes here...

data/lib/parse/stack/version.rb

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

data/lib/parse/webhooks.rb

@@ -51,7 +51,7 @@ module Parse
     #
     #  end
     # @param type (see Parse::Webhooks.route)
-    # @yield the body of the function to be evaluated in the scope of a {Parse::Payload} instance.
+    # @yield the body of the function to be evaluated in the scope of a {Parse::Webhooks::Payload} instance.
     # @param block [Symbol] the name of the method to call, if no block is passed.
     # @return (see Parse::Webhooks.route)
     def self.webhook(type, block = nil)
@@ -75,28 +75,20 @@ module Parse
 
   end
 
-  class Payload
-    # This method will intentionally raise a {WebhookErrorResponse}, which when used inside
-    # of a registered cloud code webhook function or trigger, will halt processing
-    # and return the proper error response code back to the Parse server.
-    # @param msg [String] the error message
-    # @raise WebhookErrorResponse
-    # @return [WebhookErrorResponse]
-    def error!(msg = "")
-      raise WebhookErrorResponse, msg
-    end
-  end
-
-  # The error to be raised in registered trigger or function webhook blocks that
-  # will trigger the Parse::Webhooks application to return the proper error response.
-  class WebhookErrorResponse < StandardError; end;
   # A Rack-based application middlware to handle incoming Parse cloud code webhook
   # requests.
   class Webhooks
+    # The error to be raised in registered trigger or function webhook blocks that
+    # will trigger the Parse::Webhooks application to return the proper error response.
+    class ResponseError < StandardError; end;
+
     include Client::Connectable
-    extend Webhook::Registration
+    extend Parse::Webhooks::Registration
+    # The name of the incoming env containing the webhook key.
     HTTP_PARSE_WEBHOOK = "HTTP_X_PARSE_WEBHOOK_KEY"
+    # The name of the incoming env containing the application id key.
     HTTP_PARSE_APPLICATION_ID = "HTTP_X_PARSE_APPLICATION_ID"
+    # The content type that needs to be sent back to Parse server.
     CONTENT_TYPE = "application/json"
 
     # @!attribute key
@@ -173,7 +165,7 @@ module Parse
       # This method is usually called when an incoming request from Parse Server is received.
       # @param type (see route)
       # @param className (see route)
-      # @param payload [Parse::Payload] the payload object received from the server.
+      # @param payload [Parse::Webhooks::Payload] the payload object received from the server.
       # @return [Object] the result of the trigger or function.
       def call_route(type, className, payload = nil)
         type = type.to_s.underscore.to_sym #support camelcase
@@ -219,6 +211,9 @@ module Parse
         { error: data }.to_json
       end
 
+      # Returns the configured webhook key if available. By default it will use
+      # the value of ENV['PARSE_WEBHOOK_KEY'] if not configured.
+      # @return [String]
       def key
         @key ||= ENV['PARSE_WEBHOOK_KEY']
       end
@@ -226,12 +221,18 @@ module Parse
       # Standard Rack call method. This method processes an incoming cloud code
       # webhook request from Parse Server, validates it and executes any registered handlers for it.
       # The result of the handler for the matching webhook request is sent back to
-      # Parse Server. If the handler raises a {Parse::WebhookErrorResponse},
+      # Parse Server. If the handler raises a {Parse::Webhooks::ResponseError},
       # it will return the proper error response.
+      # @raise Parse::Webhooks::ResponseError whenever {Parse::Object}, ActiveModel::ValidationError
       # @param env [Hash] the environment hash in a Rack request.
-      # @return [Object] the value of calling `finish` on the Rack::Response object.
-      # @todo Create a call! method that takes a dup of this env.
+      # @return [Array] the value of calling `finish` on the {http://www.rubydoc.info/github/rack/rack/Rack/Response Rack::Response} object.
       def call(env)
+        # Thraed safety
+        dup.call!(env)
+      end
+
+      # @!visibility private
+      def call!(env)
 
         request = Rack::Request.new env
         response = Rack::Response.new
@@ -248,7 +249,7 @@ module Parse
 
         request.body.rewind
         begin
-          payload = Parse::Payload.new request.body.read
+          payload = Parse::Webhooks::Payload.new request.body.read
         rescue => e
           warn "Invalid webhook payload format: #{e}"
           response.write error("Invalid payload format. Should be valid JSON.")
@@ -257,12 +258,12 @@ module Parse
 
         if self.logging.present?
           if payload.trigger?
-            puts "[ParseWebhooks Request] --> #{payload.trigger_name} #{payload.parse_class}:#{payload.parse_id}"
+            puts "[Webhooks::Request] --> #{payload.trigger_name} #{payload.parse_class}:#{payload.parse_id}"
           elsif payload.function?
             puts "[ParseWebhooks Request] --> Function #{payload.function_name}"
           end
           if self.logging == :debug
-            puts "[ParseWebhooks Payload] ----------------------------"
+            puts "[Webhooks::Payload] ----------------------------"
             puts payload.as_json
             puts "----------------------------------------------------\n"
           end
@@ -280,22 +281,22 @@ module Parse
             generic_result = Parse::Webhooks.call_route(payload.trigger_name, "*", payload)
             result = generic_result if generic_result.present? && result.nil?
           else
-            puts "[ParseWebhooks] --> Could not find mapping route for #{payload.to_json}"
+            puts "[Webhooks] --> Could not find mapping route for #{payload.to_json}"
           end
 
           result = true if result.nil?
           if self.logging.present?
-            puts "[ParseWebhooks Response] ----------------------------"
+            puts "[Webhooks::Response] ----------------------------"
             puts success(result)
             puts "----------------------------------------------------\n"
           end
           response.write success(result)
           return response.finish
-        rescue Parse::WebhookErrorResponse, ActiveModel::ValidationError => e
+        rescue Parse::Webhooks::ResponseError, ActiveModel::ValidationError => e
           if payload.trigger?
-            puts "[Webhook ResponseError] >> #{payload.trigger_name} #{payload.parse_class}:#{payload.parse_id}: #{e}"
+            puts "[Webhooks::ResponseError] >> #{payload.trigger_name} #{payload.parse_class}:#{payload.parse_id}: #{e}"
           elsif payload.function?
-            puts "[Webhook ResponseError] >> #{payload.function_name}: #{e}"
+            puts "[Webhooks::ResponseError] >> #{payload.function_name}: #{e}"
           end
           response.write error( e.to_s )
           return response.finish

data/lib/parse/webhooks/payload.rb

@@ -10,178 +10,191 @@ require 'active_support/core_ext'
 require 'active_model_serializers'
 
 module Parse
-    # Represents the data structure that Parse server sends to a registered webhook.
-    # Parse Parse allows you to receive Cloud Code webhooks on your own hosted
-    # server. The `Parse::Webhooks` class is a lightweight Rack application that
-    # routes incoming Cloud Code webhook requests and payloads to locally
-    # registered handlers. The payloads are `Parse::Payload` type of objects that
-    # represent that data that Parse sends webhook handlers.
-    class Payload
-    ATTRIBUTES = { master: nil, user: nil,
-           installationId: nil, params: nil,
-             functionName: nil, object: nil,
-                 original: nil, update: nil,
-                 triggerName: nil }.freeze
-    include ::ActiveModel::Serializers::JSON
-    # @!attribute [rw] master
-    #   @return [Boolean] whether the master key was used for this request.
-    # @!attribute [rw] user
-    #   @return [Parse::User] the user who performed this request or action.
-    # @!attribute [rw] installation_id
-    #   @return [String] The identifier of the device that submitted the request.
-    # @!attribute [rw] params
-    #   @return [Hash] The list of function arguments submitted for a function request.
-    # @!attribute [rw] function_name
-    #   @return [String] the name of the function.
-    # @!attribute [rw] object
-    #  In a beforeSave, this attribute is the final object that will be persisted.
-    #  @return [Hash] the object hash related to a webhook trigger request.
-    #  @see #parse_object
-    # @!attribute [rw] trigger_name
-    #  @return [String] the name of the trigger (ex. beforeSave, afterSave, etc.)
-    # @!attribute [rw] original
-    #  In a beforeSave, for previously saved objects, this attribute is the Parse::Object
-    #  that was previously in the persistent store.
-    #  @return [Hash] the object hash related to a webhook trigger request.
-    #  @see #parse_object
-    # @!attribute [rw] raw
-    #   @return [Hash] the raw payload from Parse server.
-    # @!attribute [rw] update
-    #   @return [Hash] the update payload in the request.
-    attr_accessor :master, :user, :installation_id, :params, :function_name, :object, :trigger_name
-
-    attr_accessor :original, :update, :raw
-    alias_method :installationId, :installation_id
-    alias_method :functionName, :function_name
-    alias_method :triggerName, :trigger_name
-
-    # You would normally never create a Parse::Payload object since it is automatically
-    # provided to you when using Parse::Webhooks.
-    # @see Parse::Webhooks
-    def initialize(hash = {})
-      hash = JSON.parse(hash) if hash.is_a?(String)
-      hash = Hash[hash.map{ |k, v| [k.to_s.underscore.to_sym, v] }]
-      @raw = hash
-      @master = hash[:master]
-      @user = Parse::User.new hash[:user] if hash[:user].present?
-      @installation_id = hash[:installation_id]
-      @params = hash[:params]
-      @params = @params.with_indifferent_access if @params.is_a?(Hash)
-      @function_name = hash[:function_name]
-      @object = hash[:object]
-      @trigger_name = hash[:trigger_name]
-      @original = hash[:original]
-      @update = hash[:update] || {} #it comes as an update hash
-    end
-
-    # @return [Hash]
-    def attributes
-      ATTRIBUTES
-    end
-
-    # true if this is a webhook function request.
-    def function?
-      @function_name.present?
-    end
-
-    # @return [String] the name of the Parse class for this request.
-    def parse_class
-      return nil unless @object.present?
-      @object[Parse::Model::KEY_CLASS_NAME] || @object[:className]
-    end
-
-    # @return [String] the objectId in this request.
-    def parse_id
-      return nil unless @object.present?
-      @object[Parse::Model::OBJECT_ID] || @object[:objectId]
-    end; alias_method :objectId, :parse_id
+    class Webhooks
+      # Represents the data structure that Parse server sends to a registered webhook.
+      # Parse Parse allows you to receive Cloud Code webhooks on your own hosted
+      # server. The `Parse::Webhooks` class is a lightweight Rack application that
+      # routes incoming Cloud Code webhook requests and payloads to locally
+      # registered handlers. The payloads are {Parse::Webhooks::Payload} type of objects that
+      # represent that data that Parse sends webhook handlers.
+      class Payload
+      # The set of keys that can be contained in a Parse hash payload for a webhook.
+      ATTRIBUTES = { master: nil, user: nil,
+             installationId: nil, params: nil,
+               functionName: nil, object: nil,
+                   original: nil, update: nil,
+                   triggerName: nil }.freeze
+      include ::ActiveModel::Serializers::JSON
+      # @!attribute [rw] master
+      #   @return [Boolean] whether the master key was used for this request.
+      # @!attribute [rw] user
+      #   @return [Parse::User] the user who performed this request or action.
+      # @!attribute [rw] installation_id
+      #   @return [String] The identifier of the device that submitted the request.
+      # @!attribute [rw] params
+      #   @return [Hash] The list of function arguments submitted for a function request.
+      # @!attribute [rw] function_name
+      #   @return [String] the name of the function.
+      # @!attribute [rw] object
+      #  In a beforeSave, this attribute is the final object that will be persisted.
+      #  @return [Hash] the object hash related to a webhook trigger request.
+      #  @see #parse_object
+      # @!attribute [rw] trigger_name
+      #  @return [String] the name of the trigger (ex. beforeSave, afterSave, etc.)
+      # @!attribute [rw] original
+      #  In a beforeSave, for previously saved objects, this attribute is the Parse::Object
+      #  that was previously in the persistent store.
+      #  @return [Hash] the object hash related to a webhook trigger request.
+      #  @see #parse_object
+      # @!attribute [rw] raw
+      #   @return [Hash] the raw payload from Parse server.
+      # @!attribute [rw] update
+      #   @return [Hash] the update payload in the request.
+      attr_accessor :master, :user, :installation_id, :params, :function_name, :object, :trigger_name
+
+      attr_accessor :original, :update, :raw
+      alias_method :installationId, :installation_id
+      alias_method :functionName, :function_name
+      alias_method :triggerName, :trigger_name
+
+      # You would normally never create a {Parse::Webhooks::Payload} object since it is automatically
+      # provided to you when using Parse::Webhooks.
+      # @see Parse::Webhooks
+      def initialize(hash = {})
+        hash = JSON.parse(hash) if hash.is_a?(String)
+        hash = Hash[hash.map{ |k, v| [k.to_s.underscore.to_sym, v] }]
+        @raw = hash
+        @master = hash[:master]
+        @user = Parse::User.new hash[:user] if hash[:user].present?
+        @installation_id = hash[:installation_id]
+        @params = hash[:params]
+        @params = @params.with_indifferent_access if @params.is_a?(Hash)
+        @function_name = hash[:function_name]
+        @object = hash[:object]
+        @trigger_name = hash[:trigger_name]
+        @original = hash[:original]
+        @update = hash[:update] || {} #it comes as an update hash
+      end
+
+      # @return [ATTRIBUTES]
+      def attributes
+        ATTRIBUTES
+      end
+
+      # true if this is a webhook function request.
+      def function?
+        @function_name.present?
+      end
+
+      # @return [String] the name of the Parse class for this request.
+      def parse_class
+        return nil unless @object.present?
+        @object[Parse::Model::KEY_CLASS_NAME] || @object[:className]
+      end
+
+      # @return [String] the objectId in this request.
+      def parse_id
+        return nil unless @object.present?
+        @object[Parse::Model::OBJECT_ID] || @object[:objectId]
+      end; alias_method :objectId, :parse_id
+
+      # true if this is a webhook trigger request.
+      def trigger?
+        @trigger_name.present?
+      end
+
+      # true if this is a beforeSave or beforeDelete webhook trigger request.
+      def before_trigger?
+        before_save? || before_delete?
+      end
+
+      # true if this is a afterSave or afterDelete webhook trigger request.
+      def after_trigger?
+        after_save? || after_delete?
+      end
+
+      # true if this is a beforeSave webhook trigger request.
+      def before_save?
+        trigger? && @trigger_name.to_sym == :beforeSave
+      end
+
+      # true if this is a afterSave webhook trigger request.
+      def after_save?
+        trigger? && @trigger_name.to_sym == :afterSave
+      end
+
+      # true if this is a beforeDelete webhook trigger request.
+      def before_delete?
+        trigger? && @trigger_name.to_sym == :beforeDelete
+      end
+
+      # true if this is a afterDelete webhook trigger request.
+      def after_delete?
+        trigger? && @trigger_name.to_sym == :afterDelete
+      end
+
+      # true if this request is a trigger that contains an object.
+      def object?
+        trigger? && @object.present?
+      end
+
+      # @return [Parse::Object] a Parse::Object from the original object
+      def original_parse_object
+        return nil unless @original.is_a?(Hash)
+        Parse::Object.build(@original)
+      end
+
+      # This method returns a Parse::Object by combining the original object, if was provided,
+      # with the final object. This will return a dirty tracked Parse::Object subclass,
+      # that will have information on which fields have changed between the previous state
+      # in the persistent store and the one about to be saved.
+      # @param pristine [Boolean] whether the object should be returned without dirty tracking.
+      # @return [Parse::Object] a dirty tracked Parse::Object subclass instance
+      def parse_object(pristine = false)
+        return nil unless object?
+        return Parse::Object.build(@object) if pristine
+        # if its a before trigger, then we build the original object and apply the updates
+        # in order to create a Parse::Object that has the dirty tracking information
+        # if no original is nil, then it means this is a brand new object, so we create
+        # one from the className
+        if before_trigger?
+          # if original is present, then this is a modified object
+          if @original.present? && @original.is_a?(Hash)
+            o = Parse::Object.build @original
+            o.apply_attributes! @object, dirty_track: true
 
-    # true if this is a webhook trigger request.
-    def trigger?
-      @trigger_name.present?
-    end
-
-    # true if this is a beforeSave or beforeDelete webhook trigger request.
-    def before_trigger?
-      before_save? || before_delete?
-    end
-
-    # true if this is a afterSave or afterDelete webhook trigger request.
-    def after_trigger?
-      after_save? || after_delete?
-    end
-
-    # true if this is a beforeSave webhook trigger request.
-    def before_save?
-      trigger? && @trigger_name.to_sym == :beforeSave
-    end
-
-    # true if this is a afterSave webhook trigger request.
-    def after_save?
-      trigger? && @trigger_name.to_sym == :afterSave
-    end
-
-    # true if this is a beforeDelete webhook trigger request.
-    def before_delete?
-      trigger? && @trigger_name.to_sym == :beforeDelete
-    end
-
-    # true if this is a afterDelete webhook trigger request.
-    def after_delete?
-      trigger? && @trigger_name.to_sym == :afterDelete
-    end
-
-    # true if this request is a trigger that contains an object.
-    def object?
-      trigger? && @object.present?
-    end
-
-    # @return [Parse::Object] a Parse::Object from the original object
-    def original_parse_object
-      return nil unless @original.is_a?(Hash)
-      Parse::Object.build(@original)
-    end
-
-    # This method returns a Parse::Object by combining the original object, if was provided,
-    # with the final object. This will return a dirty tracked Parse::Object subclass,
-    # that will have information on which fields have changed between the previous state
-    # in the persistent store and the one about to be saved.
-    # @param pristine [Boolean] whether the object should be returned without dirty tracking.
-    # @return [Parse::Object] a dirty tracked Parse::Object subclass instance
-    def parse_object(pristine = false)
-      return nil unless object?
-      return Parse::Object.build(@object) if pristine
-      # if its a before trigger, then we build the original object and apply the updates
-      # in order to create a Parse::Object that has the dirty tracking information
-      # if no original is nil, then it means this is a brand new object, so we create
-      # one from the className
-      if before_trigger?
-        # if original is present, then this is a modified object
-        if @original.present? && @original.is_a?(Hash)
-          o = Parse::Object.build @original
-          o.apply_attributes! @object, dirty_track: true
-
-          if o.is_a?(Parse::User) && @update.present? && @update["authData"].present?
-            o.auth_data = @update["authData"]
-          end
-          return o
-        else #else the object must be new
-          klass = Parse::Object.find_class parse_class
-          # if we have a class, return that with updated changes, otherwise
-          # default to regular object
-          if klass.present?
-            o = klass.new(@object || {})
             if o.is_a?(Parse::User) && @update.present? && @update["authData"].present?
               o.auth_data = @update["authData"]
             end
             return o
-          end # if klass.present?
-        end # if we have original
-
-      end # if before_trigger?
-      Parse::Object.build(@object)
+          else #else the object must be new
+            klass = Parse::Object.find_class parse_class
+            # if we have a class, return that with updated changes, otherwise
+            # default to regular object
+            if klass.present?
+              o = klass.new(@object || {})
+              if o.is_a?(Parse::User) && @update.present? && @update["authData"].present?
+                o.auth_data = @update["authData"]
+              end
+              return o
+            end # if klass.present?
+          end # if we have original
+
+        end # if before_trigger?
+        Parse::Object.build(@object)
+      end
+
+      # This method will intentionally raise a {Parse::Webhooks::ResponseError} with
+      # a specific message. When used inside of a registered cloud code webhook
+      # function or trigger, will halt processing and return the proper error response
+      # code back to the Parse server.
+      # @param msg [String] the error message to send back.
+      # @raise Parse::Webhooks::ResponseError
+      # @return [Parse::Webhooks::ResponseError] the raised exception
+      def error!(msg = "")
+        raise Parse::Webhooks::ResponseError, msg
+      end
+
+      end # Payload
     end
-
-    end # Payload
-
 end