parse-stack 1.0.0

data/lib/parse/query/constraint.rb

@@ -0,0 +1,130 @@
+require_relative 'operation'
+require 'time'
+# Constraints are the heart of the Parse::Query system.
+# Each constraint is made up of an Operation and a value (the right side
+# of an operator). Constraints are responsible for making their specific
+# Parse hash format required when sending Queries to Parse. All constraints can
+# be combined by merging different constraints (since they are multiple hashes)
+# and some constraints may have higher precedence than others (ex. equality is higher
+# precedence than an "in" query).
+# All constraints should inherit from Parse::Constraint and should
+# register their specific Operation method (ex. :eq or :lte)
+# For more information about the query design pattern from DataMapper
+# that inspired this, see http://datamapper.org/docs/find.html
+module Parse
+  class Constraint
+
+    attr_accessor :operation, :value
+    # A constraint needs an operation and a value.
+    # You may also pass a block to modify the operation if needed
+    def initialize(operation, value)
+      # if the first parameter is not an Operation, but it is a symbol
+      # it most likely is just the field name, so let's assume they want
+      # the default equality operation.
+      if operation.is_a?(Operation) == false && operation.respond_to?(:to_sym)
+          operation = Operation.new(operation.to_sym, :eq)
+      end
+      @operation = operation
+      @value = value
+      yield(self) if block_given?
+
+    end
+
+    # Creates a new constraint given an operation and value.
+    def self.create(operation, value)
+      #default to a generic equality constraint if not passed an operation
+      unless operation.is_a?(Parse::Operation) && operation.valid?
+        return self.new(operation, value)
+      end
+      operation.constraint(value)
+    end
+
+    class << self
+      # The class attributes keep track of the Parse key (special Parse
+      # text symbol representing this operation. Ex. local method could be called
+      # .ex, where the Parse Query operation that should be sent out is "$exists")
+      # in this case, key should be set to "$exists"
+      attr_accessor :key
+      # Precedence defines the priority of this operation when merging.
+      # The higher the more priority it will receive.
+      attr_accessor :precedence
+
+      # method to set the keyword for this Constaint (subclasses)
+      def contraint_keyword(k)
+        @key = k
+      end
+
+      def precedence(v = nil)
+        @precedence = 0 if @precedence.nil?
+        @precedence = v unless v.nil?
+        @precedence
+      end
+
+    end
+
+    def precedence
+      self.class.precedence
+    end
+
+    def key
+      self.class.key
+    end
+
+    # All subclasses should register their operation and themselves
+    # as the handler.
+    def self.register(op, klass = self)
+      Operation.register op, klass
+    end
+
+    def operand
+      @operation.operand unless @operation.nil?
+    end
+    def operand=(o)
+      @operation.operand = o unless @operation.nil?
+    end
+
+    def operator
+      @operation.operator unless @operation.nil?
+    end
+
+    def operator=(o)
+      @operation.operator = o unless @operation.nil?
+    end
+
+    def inspect
+      "<#{self.class} #{operator.to_s}(#{operand.inspect}, `#{value}`)>"
+    end
+
+    def as_json(*args)
+      build
+    end
+
+    # subclasses should override the build method depending on how they
+    # need to construct the Parse formatted query hash
+    # The default case below is for supporting equality.
+    # Before the final value is set int he hash, we call formatted_value in case
+    # we need to format the value for particular data types.
+    def build
+      return { @operation.operand => formatted_value } if @operation.operator == :eq || key.nil?
+      { @operation.operand => { key => formatted_value } }
+    end
+
+    def to_s
+      inspect
+    end
+
+    # This method formats the value based on some specific data types.
+    def formatted_value
+      d = @value
+      d = { __type: "Date", iso: d.iso8601(3) } if d.respond_to?(:iso8601)
+      d = d.pointer if d.respond_to?(:pointer) #simplified query object
+      #d = d.pointer if d.is_a?(Parse::Object) #simplified query object
+      d = d.source if d.is_a?(Regexp)
+      d
+    end
+
+    register :eq, Constraint
+    register :eql, Constraint
+    precedence 100
+  end
+end

data/lib/parse/query/constraints.rb

@@ -0,0 +1,176 @@
+require_relative 'constraint'
+
+# Eac constraint type is a subclass of Parse::Constraint
+# We register each keyword (which is the Parse query operator)
+# and the local operator we want to use. Each of the registered local
+# operators are added as methods to the Symbol class.
+# For more information: https://parse.com/docs/rest/guide#queries
+# For more information about the query design pattern from DataMapper
+# that inspired this, see http://datamapper.org/docs/find.html
+module Parse
+
+  class CompoundQueryConstraint < Constraint
+    contraint_keyword :$or
+    register :or
+
+    def build
+      or_clauses = formatted_value
+      or_clauses = [or_clauses] unless or_clauses.is_a?(Array)
+      return { :$or => or_clauses }
+    end
+
+  end
+
+  class LessOrEqualConstraint < Constraint
+    contraint_keyword :$lte
+    register :lte
+  end
+
+  class LessThanConstraint < Constraint
+    contraint_keyword :$lt
+    register :lt
+  end
+
+  class GreaterThanConstraint < Constraint
+    contraint_keyword :$gt
+    register :gt
+  end
+
+  class GreaterOrEqualConstraint < Constraint
+    contraint_keyword :$gte
+    register :gte
+  end
+
+  class NotEqualConstraint < Constraint
+    contraint_keyword :$ne
+    register :not
+  end
+
+  # Mapps all items contained in the array
+  class ContainedInConstraint < Constraint
+    contraint_keyword :$in
+    register :in
+    register :contained_in
+
+    def build
+      val = formatted_value
+      val = [val].compact unless val.is_a?(Array)
+      { @operation.operand => { key => val } }
+    end
+
+  end
+
+  # Nullabiliity constraint maps $exist Parse clause a bit differently
+  # Parse currently has a bug that if you select items near a location
+  # and want to make sure a different column has a value, you need to
+  # search where the column does not contani a null/undefined value.
+  # Therefore we override the build method to change the operation to a
+  # NotEqualConstraint
+  class NullabilityConstraint < Constraint
+    contraint_keyword :$exists
+    register :null
+    def build
+      # if nullability is equal true, then $exists should be set to false
+
+      if formatted_value == true
+        return { @operation.operand => { key => false} }
+      else
+        #current bug in parse where if you want exists => true with geo queries
+        # we should map it to a "not equal to null" constraint
+        return { @operation.operand => { Parse::NotEqualConstraint.key => nil } }
+      end
+
+    end
+  end
+
+  class ExistsConstraint < Constraint
+    contraint_keyword :$exists
+    register :exists
+    def build
+      # if nullability is equal true, then $exists should be set to false
+      return { @operation.operand => { key => formatted_value } }
+    end
+  end
+
+  class NotContainedInConstraint < Constraint
+    contraint_keyword :$nin
+    register :not_in
+    register :not_contained_in
+  end
+
+  # All Things must be contained
+  class ContainsAllConstraint < Constraint
+    contraint_keyword :$all
+    register :all
+    register :contains_all
+  end
+
+  class SelectionConstraint < Constraint
+    #This matches a value for a key in the result of a different query
+    contraint_keyword :$select
+    register :select
+  end
+
+  class RejectionConstraint < Constraint
+    #requires that a key's value not match a value for a key in the result of a different query
+    contraint_keyword :$dontSelect
+    register :reject
+
+  end
+
+  class RegularExpressionConstraint < Constraint
+    #Requires that a key's value match a regular expression
+    contraint_keyword :$regex
+    register :like
+    register :regex
+  end
+
+  # Does the propert relational constraint.
+  class RelationQueryConstraint < Constraint
+    # matches objects in a specific column in a different class table
+    contraint_keyword :$relatedTo
+    register :related_to
+    register :rel
+    def build
+      # pointer = formatted_value
+      # unless pointer.is_a?(Parse::Pointer)
+      #   raise "Invalid Parse::Pointer passed to :related(#{@operation.operand}) constraint : #{pointer}"
+      # end
+      { :$relatedTo => { object: formatted_value, key: @operation.operand } }
+    end
+  end
+
+  class JoinQueryConstraint < Constraint
+    contraint_keyword :$inQuery
+    register :join
+    register :in_query
+
+  end
+
+  class DisjointQueryConstraint < Constraint
+    contraint_keyword :$notInQuery
+    register :exclude
+    register :not_in_query
+
+  end
+
+  class NearSphereQueryConstraint < Constraint
+    contraint_keyword :$nearSphere
+    register :near
+
+    def build
+      point = formatted_value
+      max_miles = nil
+      if point.is_a?(Array) && point.count > 1
+        max_miles = point[2] if point.count == 3
+        point = { __type: "GeoPoint", latitude: point[0], longitude: point[1] }
+      end
+      if max_miles.present? && max_miles > 0
+        return { @operation.operand => { key => point, :$maxDistanceInMiles => max_miles.to_f } }
+      end
+      { @operation.operand => { key => point } }
+    end
+
+  end
+
+end

data/lib/parse/query/operation.rb

@@ -0,0 +1,66 @@
+require 'active_support/inflector'
+
+# The base operation class used in generating queries.
+# An Operation contains an operand (field) and the
+# operator (ex. equals, greater than, etc)
+# Each unique operation type needs a handler that is responsible
+# for creating a Constraint with a given value.
+# When creating a new operation, you need to register the operation
+# method and the class that will be the handler.
+module Parse
+  class Operation
+    attr_accessor :operand, :operator
+    class << self
+      attr_accessor :operators
+      def operators
+        @operators ||= {}
+      end
+    end
+    # a valid Operation has a handler, operand and operator.
+    def valid?
+      ! (@operand.nil? || @operator.nil? || handler.nil?)
+    end
+
+    # returns the constraint class designed to handle this operator
+    def handler
+      Operation.operators[@operator] unless @operator.nil?
+    end
+
+    def initialize(field, op)
+      self.operand = field.to_sym
+      self.operand = :objectId if operand == :id
+      self.operator = op.to_sym
+    end
+
+    def inspect
+      "#{operator.inspect}(#{operand.inspect})"
+    end
+
+    # create a new constraint based on the handler that had
+    # been registered with this operation.
+    def constraint(value = nil)
+      handler.new(self, value)
+    end
+
+    # have a way to register an operation type.
+    # Example:
+    # register :eq, MyEqualityHandlerClass
+    # the above registered the equality operator which we define to be
+    # a new method on the Symbol class ('eq'), which when passed a value
+    # we will forward the request to the MyEqualityHandlerClass, so that
+    # for a field called 'name', we can do
+    #
+    # :name.eq (returns operation)
+    # :name.eq(value) # returns constraint provided by the handler
+    #
+    def self.register(op, klass)
+        Operation.operators[op.to_sym] = klass
+        Symbol.send :define_method, op do |value = nil|
+          operation = Operation.new self, op
+          value.nil? ? operation : operation.constraint(value)
+        end
+    end
+
+  end
+
+end

data/lib/parse/query/ordering.rb

@@ -0,0 +1,49 @@
+# Ordering is implemented similarly as constraints in which we add
+# special methods to the Symbol class. The developer can then pass one
+# or an array of fields (as symbols) and call the particular ordering
+# polarity (ex. :name.asc would create a Parse::Order where we want
+# things to be sortd by the name field in ascending order)
+# For more information about the query design pattern from DataMapper
+# that inspired this, see http://datamapper.org/docs/find.html
+module Parse
+    class Order
+      # We only support ascending and descending
+      ORDERING = {asc: '', desc: '-'}.freeze
+      attr_accessor :field, :direction
+
+      def initialize(field, order = :asc)
+        @field = field.to_sym || :objectId
+        @direction = order
+      end
+
+      def field=(f)
+        @field = f.to_sym
+      end
+
+      # get the Parse keyword for ordering.
+      def polarity
+        ORDERING[@direction] || ORDERING[:asc]
+      end # polarity
+
+      def to_s
+        "" if @field.nil?
+         polarity + @field.to_s
+      end
+
+      def inspect
+        "#{@direction.to_s}(#{@field.inspect})"
+      end
+
+    end # Order
+
+end
+
+# Add all the operator instance methods to the symbol classes
+class Symbol
+  Parse::Order::ORDERING.keys.each do |sym|
+    define_method(sym) do
+      Parse::Order.new self, sym
+    end
+  end # each
+
+end

data/lib/parse/stack.rb

@@ -0,0 +1,11 @@
+require_relative "stack/version"
+require_relative 'client'
+require_relative 'query'
+require_relative 'model/object'
+require_relative 'webhooks'
+
+module Parse
+  module Stack
+    # Your code goes here...
+  end
+end

data/lib/parse/stack/version.rb

@@ -0,0 +1,5 @@
+module Parse
+  module Stack
+    VERSION = "1.0.0"
+  end
+end

data/lib/parse/webhooks.rb

@@ -0,0 +1,228 @@
+
+require 'active_model'
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext/object'
+require 'active_model_serializers'
+require 'rack'
+require_relative 'client'
+require_relative 'stack'
+require_relative 'model/object'
+require_relative 'webhooks/payload'
+require_relative 'webhooks/registration'
+
+
+=begin
+  Some methods take a block, and this pattern frequently appears for a block:
+
+  {|x| x.foo}
+  and people would like to write that in a more concise way. In order to do that,
+   a symbol, the method Symbol#to_proc, implicit class casting, and & operator
+   are used in combination. If you put & in front of a Proc instance in the
+   argument position, that will be interpreted as a block. If you combine
+   something other than a Proc instance with &, then implicit class casting
+   will try to convert that to a Proc instance using to_proc method defined on
+   that object if there is any. In case of a Symbol instance, to_proc works in
+   this way:
+
+    :foo.to_proc # => ->x{x.foo}
+
+   For example, suppose you write like this:
+
+    bar(&:foo)
+   The & operator is combined with :foo, which is not a Proc instance, so implicit class cast applies Symbol#to_proc to it, which gives ->x{x.foo}. The & now applies to this and is interpreted as a block, which gives:
+
+   bar{|x| x.foo}
+=end
+
+module Parse
+
+  class Object
+
+    def self.webhook_function(functionName, block = nil)
+      if block_given?
+        Parse::Webhooks.route(:function, functionName, &Proc.new)
+      else
+        block = functionName.to_s.underscore.to_sym if block.blank?
+        block = method(block.to_sym) if block.is_a?(Symbol)
+        Parse::Webhooks.route(:function, functionName, block)
+      end
+    end
+
+    def self.webhook(type, block = nil)
+
+      if type == :function
+        unless block.is_a?(String) || block.is_a?(Symbol)
+          raise "Invalid Cloud Code function name: #{block}"
+        end
+        Parse::Webhooks.route(:function, block, &Proc.new)
+        # then block must be a symbol or a string
+      else
+        if block_given?
+          Parse::Webhooks.route(type, self, &Proc.new)
+        else
+          Parse::Webhooks.route(type, self, block)
+        end
+      end
+      #if block
+
+    end
+
+    def update_payload
+      h = attribute_updates
+      if relation_changes?
+        r =  relation_change_operations.select { |s| s.present? }.first
+        h.merge!(r) if r.present?
+      end
+      h.merge!(className: parse_class) unless h.empty?
+      h.as_json
+    end
+
+  end
+
+  class Webhooks
+
+    include Client::Connectable
+    extend Webhook::Registration
+
+    HTTP_PARSE_WEBHOOK = "HTTP_X_PARSE_WEBHOOK_KEY".freeze
+    HTTP_PARSE_APPLICATION_ID = "HTTP_X_PARSE_APPLICATION_ID".freeze
+    CONTENT_TYPE = "application/json".freeze
+
+    attr_accessor :key
+    class << self
+      attr_accessor :logging
+      def routes
+        @routes ||= OpenStruct.new( {
+          before_save: {}, after_save: {},
+          before_delete: {}, after_delete: {}, function: {}
+          })
+      end
+
+      def route(type, className, block = nil)
+        type = type.to_s.underscore.to_sym #support camelcase
+        if type != :function && className.respond_to?(:parse_class)
+          className = className.parse_class
+        end
+        className = className.to_s
+        block = Proc.new if block_given?
+        if routes[type].nil? || block.respond_to?(:call) == false
+          raise "Invalid Webhook registration trigger #{type} #{className}"
+        end
+
+        # AfterSave/AfterDelete hooks support more than one
+        if type == :after_save || type == :after_delete
+
+          routes[type][className] ||= []
+          routes[type][className].push block
+        else
+          routes[type][className] = block
+        end
+        #puts "Webhook: #{type} -> #{className}..."
+      end
+
+      def call_route(type, className, payload = nil)
+        type = type.to_s.underscore.to_sym #support camelcase
+        className = className.parse_class if className.respond_to?(:parse_class)
+        className = className.to_s
+
+        return unless routes[type].present? && routes[type][className].present?
+        registry = routes[type][className]
+
+        if registry.is_a?(Array)
+          results = registry.map { |hook| hook.call(payload) }
+          return results.last
+        else
+          return registry.call(payload)
+        end
+        nil
+      end
+
+      def success(data = true)
+        { success: data }.to_json
+      end
+
+      def error(data = false)
+        { error: data }.to_json
+      end
+
+      def key
+        @key ||= ENV['PARSE_WEBHOOK_KEY']
+      end
+
+      def call(env)
+
+        request = Rack::Request.new env
+        response = Rack::Response.new
+
+        if @key.present? && @key =! request.env[HTTP_PARSE_WEBHOOK]
+          response.write error("Invalid Parse-Webhook Key")
+          return response.finish
+        end
+
+        unless request.content_type.include?(CONTENT_TYPE)
+          response.write error("Invalid content-type format. Should be application/json.")
+          return response.finish
+        end
+
+        request.body.rewind
+        begin
+          payload = Parse::Payload.new request.body.read
+        rescue Exception => e
+          warn "Invalid webhook payload format: #{e}"
+          response.write error("Invalid payload format. Should be valid JSON.")
+          return response.finish
+        end
+
+        if self.logging.present?
+          if payload.trigger?
+            puts "[ParseWebhooks 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 payload.as_json
+            puts "----------------------------------------------------\n"
+          end
+        end
+
+        begin
+          result = true
+          if payload.function? && payload.function_name.present?
+            result = Parse::Webhooks.call_route(:function, payload.function_name, payload)
+          elsif payload.trigger? && payload.parse_class.present? && payload.trigger_name.present?
+            # call hooks subscribed to the specific class
+            result = Parse::Webhooks.call_route(payload.trigger_name, payload.parse_class, payload)
+
+            # call hooks subscribed to any class route
+            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}"
+          end
+
+          result = true if result.blank?
+          if self.logging.present?
+            puts "[ParseWebhooks Response] ----------------------------"
+            puts success(result)
+            puts "----------------------------------------------------\n"
+          end
+          response.write success(result)
+          return response.finish
+        rescue Exception => e
+          puts "[ParseWebhooks Error] >> #{e}"
+          puts e.backtrace
+          response.write error( e.to_s )
+          return response.finish
+        end
+
+        #check if we can handle the type trigger/functionName
+        response.write( success )
+        response.finish
+      end # call
+
+    end #class << self
+  end # Webhooks
+
+end # Parse