parse-stack 1.3.7 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36eda4b2e4b7cfabe79550eb3c33345f6d9fdaaf
-  data.tar.gz: efdef75bc9457d307563f5e0e254733cb2c638fa
+  metadata.gz: 18eab2bb5c64686e9b7713d4083db00fd5b7d026
+  data.tar.gz: 21cc6c542518c284edcd90c8ff8c09df4883dd30
 SHA512:
-  metadata.gz: dc156d8689d64921540fb44c3fc41446c4bfc67ea869d6f6c73e28a32ae0398089bdd2b7691c9df0ccce6cfcc893abbf872090439906580edc7c3bd9e1568075
-  data.tar.gz: b07ef6631868a733b0967fcf0e3cad592f46e179d451e61d1ea3826130f0f00a9e85861796d1a49d2db0bbe160fb1e680a6884e7c46749f5026beb9d9b8090bc
+  metadata.gz: 38a5decb6fbbb89caa454ac583ea9cfbad0929a59bbfa78b86befc00bb53a861f040951ce9bb6013a6b03bb0fb086bd98438c00927da2030a66cb57798159858
+  data.tar.gz: 8c16ed21c5c450270382d8223d010978de8950cbd9cfaf3172d2915f1e81d73a151b55176b61e41f1fbd662fa6a8c1554e620650c9a92aec84cdb26446fd26b3

data/.gitignore

@@ -37,3 +37,5 @@ build/
 .rvmrc
 bin/.env
 /.byebug_history
+/.env
+/node_modules

data/Changes.md

@@ -1,12 +1,21 @@
 # Parse-Stack Changes
 
+1.3.8
+-----------
+- Support for reloading the Parse config data with `Parse.config!`.
+- The Parse::Request object is now provided in the Parse::Response instance.
+- The HTTP status code is provided in `http_status` accessor for a Parse::Response.
+- Raised errors now provide info on the request that failed.
+- Added new `ServiceUnavailableError` exception for Parse error code 2 and HTTP 503 errors.
+- Upon a `ServiceUnavailableError`, we will retry the request one more time after 2 seconds.
+- `:not_in` and `:contains_all` queries will format scalar values into an array.
+- `:exists` and `:null` will raise `ParseConstraintError` if non-boolean values are passed.
+- NEW: `:id` constraint to allow passing an objectId to a query where we will infer the class.
+
 1.3.7
 -----------
 - Fixes json_api loading issue between ruby json and active_model_serializers.
 - Fixes loading active_support core extensions.
-
-1.3.5
------------
 - Support for passing a `:session_token` as part of a Parse::Query.
 - Default mime-type for Parse::File instances is `image/jpeg`. You can override the default by setting
 `Parse::File.default_mime_type`.
@@ -19,10 +28,9 @@
 - Added `$within` => `$box` GeoPoint query. (see documentation)
 - Improves support when using Parse-Server.
 - Major documentation updates.
-- `limit` no longer defaults to 100 in `Parse::Query`. This will allow Parse-Server to determine default limit, if any. (1.3.4)
-- `:bool` property type has been added as an alias to `:boolean`. (1.3.5)
-- You can turn off formatting field names with `Parse::Query.field_formatter = nil`. (1.3.5)
-
+- `limit` no longer defaults to 100 in `Parse::Query`. This will allow Parse-Server to determine default limit, if any.
+- `:bool` property type has been added as an alias to `:boolean`.
+- You can turn off formatting field names with `Parse::Query.field_formatter = nil`.
 
 1.3.1
 -----------

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parse-stack (1.3.7)
+    parse-stack (1.3.8)
       active_model_serializers (>= 0.9, < 1)
       activemodel (>= 4.2.1, < 6)
       activesupport (>= 4.2.1, < 6)
@@ -14,15 +14,15 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (5.0.0)
-      actionview (= 5.0.0)
-      activesupport (= 5.0.0)
+    actionpack (5.0.0.1)
+      actionview (= 5.0.0.1)
+      activesupport (= 5.0.0.1)
       rack (~> 2.0)
       rack-test (~> 0.6.3)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (5.0.0)
-      activesupport (= 5.0.0)
+    actionview (5.0.0.1)
+      activesupport (= 5.0.0.1)
       builder (~> 3.1)
       erubis (~> 2.7.0)
       rails-dom-testing (~> 2.0)
@@ -32,9 +32,9 @@ GEM
       activemodel (>= 4.1, < 6)
       jsonapi (~> 0.1.1.beta2)
       railties (>= 4.1, < 6)
-    activemodel (5.0.0)
-      activesupport (= 5.0.0)
-    activesupport (5.0.0)
+    activemodel (5.0.0.1)
+      activesupport (= 5.0.0.1)
+    activesupport (5.0.0.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
       minitest (~> 5.1)
@@ -85,9 +85,9 @@ GEM
       nokogiri (~> 1.6.0)
     rails-html-sanitizer (1.0.3)
       loofah (~> 2.0)
-    railties (5.0.0)
-      actionpack (= 5.0.0)
-      activesupport (= 5.0.0)
+    railties (5.0.0.1)
+      actionpack (= 5.0.0.1)
+      activesupport (= 5.0.0.1)
       method_source
       rake (>= 0.8.7)
       thor (>= 0.18.1, < 2.0)

data/README.md

@@ -1,5 +1,5 @@
 # Parse-Stack - A Parse-Server Ruby Client and ORM
-Parse Stack is an opinionated framework for ruby applications that utilize the [Parse Server Platform](https://github.com/ParsePlatform/parse-server). It provides a client adapter, a query engine, an object relational mapper (ORM) and a Cloud Code Webhooks rack application.
+Parse-Stack is a [Parse Server](https://github.com/ParsePlatform/parse-server) REST API Client and ORM framework for ruby. It provides a client adapter, a query engine, an object relational mapper (ORM) and a Cloud Code Webhooks rack application.
 
 ### Code Status
 [![Gem Version](https://badge.fury.io/rb/parse-stack.svg)](https://badge.fury.io/rb/parse-stack)
@@ -17,8 +17,10 @@ Parse Stack is an opinionated framework for ruby applications that utilize the [
   - [Parse::Query](#parsequery)
   - [Parse::Object](#parseobject)
   - [Parse::Webhooks](#parsewebhooks)
+- [Field Naming Conventions](#field-naming-conventions)
 - [Connection Setup](#connection-setup)
   - [Connection Options](#connection-options)
+- [Parse Config](#parse-config)
 - [Core Classes](#core-classes)
   - [Parse::Pointer](#parsepointer)
   - [Parse::File](#parsefile)
@@ -26,6 +28,10 @@ Parse Stack is an opinionated framework for ruby applications that utilize the [
   - [Parse::GeoPoint](#parsegeopoint)
     - [Calculating Distances between locations](#calculating-distances-between-locations)
   - [Parse::Bytes](#parsebytes)
+  - [Parse::User](#parseuser)
+  - [Parse::Installation](#parseinstallation)
+  - [Parse::Session](#parsesession)
+  - [Parse::Role](#parserole)
 - [Modeling and Subclassing](#modeling-and-subclassing)
   - [Defining Properties](#defining-properties)
     - [Accessor Aliasing](#accessor-aliasing)
@@ -73,6 +79,7 @@ Parse Stack is an opinionated framework for ruby applications that utilize the [
     - [Reject](#reject)
     - [Matches Query](#matches-query)
     - [Excludes Query](#excludes-query)
+    - [Matches Object Id](#matches-object-id)
   - [Geo Queries](#geo-queries)
     - [Max Distance Constraint](#max-distance-constraint)
     - [Bounding Box Constraint](#bounding-box-constraint)
@@ -119,16 +126,27 @@ class Song < Parse::Object
   has_many :likes, as: :user, through: :relation
 end
 
-# create tables or add new columns (non-destructive)
-Song.auto_upgrade!
+class Artist < Parse::Object
+  property :name
+  property :genres, :array
+end
+
+# updates schemas for your Parse app based on your models (non-destructive)
+Parse.auto_upgrade!
 
+artist = Artist.new(name: "Frank Sinatra", genres: ["swing", "jazz"])
+artist.save
+
+# Query
 artist = Artist.first(:name.like => /Sinatra/, :genres.in => ['swing'])
 
+# more examples
 song = Song.new name: "Fly Me to the Moon"
 song.artist = artist
-# Parse files
+# Parse files - upload a file and attach to object
 song.audio_file = Parse::File.create("http://path_to.mp3")
-# relations
+
+# relations - find a User matching username and add it to relation.
 song.likes.add Parse::User.first(username: "persaud")
 
 # saves both attributes and relations
@@ -149,6 +167,7 @@ result = Parse.call_function :myFunctionName, {param: value}
 ## Main Features
 While there are many additional features of the framework, these are the main points.
 
+- Support for all Parse Query constraints.
 - Object Relational Mapping with dirty tracking.
 - Easy management of Parse GeoPoints, Files and ACLs.
 - Parse Queries support with caching middleware. (Reduces API usage)
@@ -253,6 +272,19 @@ Sets the default cache expiration time (in seconds) for successful non-empty `GE
 #### `:faraday`
 You may pass a hash of options that will be passed to the `Faraday` constructor.
 
+## Parse Config
+Getting your configuration variables once you have a default client setup can be done with `Parse.config`. The first time this method is called, Parse-Stack will get the configuration from Parse-Server, and cache it. To force a reload of the config, use `config!`.
+
+```ruby
+  Parse.setup( ... )
+
+  val = Parse.config["myKey"]
+  val = Parse.config["myKey"] # cached
+
+  # Force fetch of config!
+  val = Parse.config!["myKey"]
+
+```
 
 ## Core Classes
 While some native data types are similar to the ones supported by Ruby natively, other ones are more complex and require their dedicated classes.
@@ -381,6 +413,63 @@ The `Bytes` data type represents the storage format for binary content in a Pars
   decoded = bytes.decoded # same as Base64.decode64
 ```
 
+### Parse::User
+This class represents the data and columns contained in the standard Parse `_User` collection. You may add additional properties and methods to this class. It is defined as follows:
+
+```ruby
+class Parse::User < Parse::Object
+  property :auth_data, :object
+  property :email
+  property :password
+  property :username
+end
+```
+
+### Parse::Installation
+This class represents the data and columns contained in the standard Parse `_Installation` collection. You may add additional properties and methods to this class. It is defined as follows:
+
+```ruby
+class Parse::Installation < Parse::Object
+  property :channels, :array
+  property :gcm_sender_id, :string, field: :GCMSenderId
+  property :badge, :integer
+  property :installation_id
+  property :device_token
+  property :device_type
+  property :locale_identifier
+  property :push_type
+  property :time_zone
+end
+```
+
+### Parse::Session
+This class represents the data and columns contained in the standard Parse `_Session` collection. You may add additional properties and methods to this class. It is defined as follows:
+
+```ruby
+class Parse::Session < Parse::Object
+  property :created_with, :object
+  property :expires_at, :date
+  property :installation_id
+  property :restricted, :boolean
+  property :session_token
+
+  belongs_to :user
+end
+```
+
+### Parse::Role
+This class represents the data and columns contained in the standard Parse `_Role` collection. You may add additional properties and methods to this class. It is defined as follows:
+
+```ruby
+class Parse::Role < Parse::Object
+  property :name
+
+  has_many :roles, through: :relation
+  has_many :users, through: :relation
+end
+```
+
+
 ## Modeling and Subclassing
 For the general case, your Parse classes should inherit from `Parse::Object`. `Parse::Object` utilizes features from `ActiveModel` to add several features to each instance of your subclass. These include `Dirty`, `Conversion`, `Callbacks`, `Naming` and `Serializers::JSON`.
 
@@ -1134,6 +1223,17 @@ q.where :field => value
 # (alias) :field.eq => value
 ```
 
+If you want to see if a particular field contains a specific Parse::Object (pointer), you can use the following:
+
+```ruby
+# find rows where the `field` contains a Parse "_User" pointer with the specified objectId.
+q.where :field => Parse::Pointer.new("_User", "anObjectId")
+# alias using subclass helper
+q.where :field => Parse::User.pointer("anObjectId")
+# alias using `:id` constraint. We will infer :user maps to class "_User" (Parse::User)
+q.where :user.id => "anObjectId"
+```
+
 #### Less Than
 Equivalent to the `$lt` Parse query operation. The alias `before` is provided for readability.
 
@@ -1196,7 +1296,7 @@ q.where :field.exists => true|false
 ```
 
 #### Contained In
-Equivalent to the `$in` Parse query operation. Checks whether the value in the column field is contained in the set of values in the array.
+Equivalent to the `$in` Parse query operation. Checks whether the value in the column field is contained in the set of values in the target array. If the field is an array data type, it checks whether at least one value in the field array is contained in the set of values in the target array.
 
 ```ruby
 # ex. :score.in => [1,3,5,7,9]
@@ -1206,7 +1306,7 @@ q.where :field.contained_in => [item1,item2,...]
 ```
 
 #### Not Contained In
-Equivalent to the `$nin` Parse query operation. Checks whether the value in the column field is __not__ contained in the set of values in the array.
+Equivalent to the `$nin` Parse query operation. Checks whether the value in the column field is __not__ contained in the set of values in the target array. If the field is an array data type, it checks whether at least one value in the field array is __not__ contained in the set of values in the target array.
 
 ```ruby
 # ex. :player_name.not_in => ['Jonathan', 'Dario', 'Shawn']
@@ -1216,7 +1316,7 @@ q.where :field.not_contained_in => [item1,item2,...]
 ```
 
 #### Contains All
-Equivalent to the `$all` Parse query operation. Checks whether the value in the column field contains all of the given values provided in the array. Note that the `field` column must be of type `Array` in your Parse class.
+Equivalent to the `$all` Parse query operation. Checks whether the value in the column field contains all of the given values provided in the array. Note that the `field` column should be of type `Array` in your Parse class.
 
 ```ruby
  # ex. :array_key.all => [2,3,4]
@@ -1283,6 +1383,48 @@ q.where :field.excludes => query
 q.where :field.not_in_query => query # alias
 ```
 
+#### Matches Object Id
+Sometimes you want to find rows where a particular Parse object exists. You can do so by passing a the Parse::Object subclass, a Parse::Pointer. You can also use the `id` constraint. This will assume that the name of the field matches a particular Parse class you have defined. Assume the following:
+
+```ruby
+# where this Parse object equals the object in the column `field`.
+q.where :field => Parse::Pointer("Field", "someObjectId")
+# alias, shorthand when we infer `:field` maps to `Field` parse class.
+q.where :field.id => "someObjectId"
+# "field":{"__type":"Pointer","className":"Field","objectId":"someObjectId"}}
+
+```
+
+##### Additional Examples
+
+```ruby
+
+class Artist < Parse::Object
+  # as described before
+end
+
+class Song < Parse::Object
+  belongs_to :artist
+end
+
+artist = Artist.first # get any artist
+artist_id = artist.id # ex. artist.id
+
+# find all songs for this artist object
+Song.all :artist => artist
+```
+
+In some cases, you do not have the Parse object, but you have its `objectId`. You can use the objectId in the query as follows:
+
+```ruby
+# shorthand if you are using convention. Will infer class `Artist`
+Song.all :artist.id => artist_id
+
+# other approaches, same result
+Song.all :artist => Artist.pointer(artist_id)
+Song.all :artist => Parse::Pointer.new("Artist", artist_id)
+```
+
 ### Geo Queries
 Equivalent to the `$nearSphere` Parse query operation. This is only applicable if the field is of type `GeoPoint`. This will query Parse and return a list of results ordered by distance with the nearest object being first.
 
@@ -1446,7 +1588,7 @@ Push notifications are implemented through the `Parse::Push` class. To send push
 ```
 
 ## Cloud Code Webhooks
-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. You can register any of the Cloud Code webhook trigger hooks (`beforeSave`, `afterSave`, `beforeDelete`, `afterDelete`) and function hooks. If you are using the open source [Parse Server](https://github.com/ParsePlatform/parse-server), you must enable this hooks feature by enabling the environment variable `PARSE_EXPERIMENTAL_HOOKS_ENABLED` on your Parse server.
+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. You can register any of the Cloud Code webhook trigger hooks (`beforeSave`, `afterSave`, `beforeDelete`, `afterDelete`) and function hooks.
 
 ### Cloud Code functions
 You can use the `route()` method to register handler blocks. The last value returned by the block will be returned back to the client in a success response. If `error!(value)` is called inside the block, we will return the correct Parse error response with the value you provided.

data/Rakefile

@@ -11,3 +11,8 @@ Rake::TestTask.new do |t|
 end
 
 task :default => :test
+
+task :console do
+  exec("./bin/console")
+end
+task :c => :console

data/bin/console

@@ -3,9 +3,12 @@
 require "bundler/setup"
 require "parse/stack"
 require 'dotenv'
+require 'byebug'
 Dotenv.load
 
 
+Parse.setup
+
 class Song < Parse::Object
   property :name
 end

data/lib/parse/api/config.rb

@@ -5,6 +5,11 @@ module Parse
     #object fetch methods
     module Config
       attr_accessor :config
+      
+      def config!
+        @config = nil
+        self.config
+      end
 
       def config
         if @config.nil?

data/lib/parse/client.rb

@@ -23,6 +23,7 @@ module Parse
   class TimeoutError < Exception; end;
   class ProtocolError < Exception; end;
   class ServerError < Exception; end;
+  class ServiceUnavailableError < Exception; end;
   class AuthenticationError < Exception; end;
   class RequestLimitExceededError < Exception; end;
   class InvalidSessionTokenError < Exception; end;
@@ -32,6 +33,10 @@ module Parse
     Parse::Client.session(s).config
   end
 
+  def self.config!(s = :default)
+    Parse::Client.session(s).config!
+  end
+
   # Main class for the client. The client class is based on a Faraday stack.
   # The Faraday stack is similar to a Rack-style application in which you can define middlewares
   # that will be called for each request going out and coming back in. We use this in order to setup
@@ -48,6 +53,8 @@ module Parse
     include Parse::API::Batch
     include Parse::API::Push
     include Parse::API::Schema
+    RETRY_COUNT = 2
+    RETRY_DELAY = 3 #seconds
 
     attr_accessor :session, :cache
     attr_reader :application_id, :api_key, :master_key, :server_url
@@ -89,9 +96,9 @@ module Parse
     # :host - defaults to Parse::Protocol::SERVER_URL (https://api.parse.com/1/)
     def initialize(opts = {})
       @server_url     = opts[:server_url] || ENV["PARSE_SERVER_URL"] || Parse::Protocol::SERVER_URL
-      @application_id = opts[:app_id] || opts[:application_id] || ENV["PARSE_APP_ID"]
-      @api_key        = opts[:api_key] || ENV["PARSE_API_KEY"]
-      @master_key     = opts[:master_key] || ENV["PARSE_MASTER_KEY"]
+      @application_id = opts[:application_id] || opts[:app_id] || ENV["PARSE_APP_ID"] || ENV['PARSE_SERVER_APPLICATION_ID']
+      @api_key        = opts[:api_key] || opts[:rest_api_key]  || ENV["PARSE_API_KEY"] || ENV["PARSE_REST_API_KEY"]
+      @master_key     = opts[:master_key] || ENV["PARSE_MASTER_KEY"] || ENV['PARSE_SERVER_MASTER_KEY']
       opts[:adapter] ||= Faraday.default_adapter
       opts[:expires] ||= 3
       if @application_id.nil? || ( @api_key.nil? && @master_key.nil? )
@@ -142,6 +149,10 @@ module Parse
       self
     end
 
+    def app_id
+      @application_id
+    end
+
     def url_prefix
       @session.url_prefix
     end
@@ -160,15 +171,19 @@ module Parse
     # with the header: paramter (also a hash).
     # This method also takes in a Parse::Request object instead of the arguments listed above.
     def request(method, uri = nil, body: nil, query: nil, headers: nil, opts: {})
+      retry_count ||= RETRY_COUNT
       headers ||= {}
       # if the first argument is a Parse::Request object, then construct it
+      _request = nil
       if method.is_a?(Request)
-        request = method
-        method = request.method
-        uri ||= request.path
-        query ||= request.query
-        body ||= request.body
-        headers.merge! request.headers
+        _request     = method
+        method       = _request.method
+        uri        ||= _request.path
+        query      ||= _request.query
+        body       ||= _request.body
+        headers.merge! _request.headers
+      else
+        _request = Parse::Request.new(method, uri, body: body, headers: headers, opts: opts)
       end
 
       # http method
@@ -196,46 +211,62 @@ module Parse
       params = (method == :get ? query : body) || {}
       # if the path does not start with the '/1/' prefix, then add it to be nice.
       # actually send the request and return the body
-      response = @session.send(method, uri, params, headers)
-      body = response.body
+      response_env = @session.send(method, uri, params, headers)
+      response = response_env.body
+      response.request = _request
 
-      case response.status
+      case response.http_status
       when 401, 403
-        puts "[ParseError] #{body}"
-        raise Parse::AuthenticationError, body
+        puts "[Parse:AuthenticationError] #{response}"
+        raise Parse::AuthenticationError, response
       when 400, 408
-          puts "[ParseError] #{body}"
-        if body.code == 124 || body.code == 143 #"net/http: timeout awaiting response headers"
-          raise Parse::TimeoutError, body
+        if response.code == Parse::Response::ERROR_TIMEOUT || response.code == 143 #"net/http: timeout awaiting response headers"
+          puts "[Parse:TimeoutError] #{response}"
+          raise Parse::TimeoutError, response
         end
       when 404
-        unless body.object_not_found?
-          puts "[ParseError] #{body}"
-          raise Parse::ConnectionError, body
+        unless response.object_not_found?
+          puts "[Parse:ConnectionError] #{response}"
+          raise Parse::ConnectionError, response
         end
       when 405, 406
-        puts "[ParseError] #{body}"
-        raise Parse::ProtocolError, body
+        puts "[Parse:ProtocolError] #{response}"
+        raise Parse::ProtocolError, response
       when 500
-        puts "[ParseError] #{body}"
-        raise Parse::ServerError, body
+        puts "[Parse:ServiceUnavailableError] #{response}"
+        raise Parse::ServiceUnavailableError, response
+      when 503
+        puts "[Parse:ServiceUnavailableError] #{response}"
+        raise Parse::ServiceUnavailableError, response
       end
 
-      if body.error?
-        if body.code <= 100
-          puts "[ParseError] #{body}"
-          raise Parse::ServerError, body
-        elsif body.code == 155
-          puts "[ParseError] #{body}"
-          raise Parse::RequestLimitExceededError, body
-        elsif body.code == 209 #Error 209: invalid session token
-          puts "[ParseError] #{body}"
-          raise Parse::InvalidSessionTokenError, body
+      if response.error?
+        if response.code <= Parse::Response::ERROR_SERVICE_UNAVAILALBE
+          puts "[Parse:ServiceUnavailableError] #{response}"
+          raise Parse::ServiceUnavailableError, response
+        elsif response.code <= 100
+          puts "[Parse:ServerError] #{response}"
+          raise Parse::ServerError, response
+        elsif response.code == Parse::Response::ERROR_EXCEEDED_BURST_LIMIT
+          puts "[Parse:RequestLimitExceededError] #{response}"
+          raise Parse::RequestLimitExceededError, response
+        elsif response.code == 209 #Error 209: invalid session token
+          puts "[Parse:InvalidSessionTokenError] #{response}"
+          raise Parse::InvalidSessionTokenError, response
         end
       end
 
-      body
+      response
+    rescue Parse::ServiceUnavailableError => e
+      if retry_count > 0
+        puts "[Parse:ServiceUnavailableError] Retries remaining #{retry_count} : #{response.request}"
+        sleep RETRY_DELAY
+        retry_count -= 1
+        retry
+      end
+      raise e
     rescue Faraday::Error::ClientError, Net::OpenTimeout => e
+      puts "[Parse:ConnectionError] Faraday/Net:OpenTimeout : #{e.message}"
       raise Parse::ConnectionError, e.message
     end
 

data/lib/parse/client/body_builder.rb

@@ -49,7 +49,7 @@ module Parse
           # of the env
           # TODO: CHECK FOR HTTP STATUS CODES
           if self.class.logging
-            puts "[[Response ]] --------------------------------------"
+            puts "[[Response #{response_env[:status]}]] ----------------------------------"
             puts response_env.body
             puts "[[Response]] --------------------------------------\n"
           end
@@ -59,9 +59,9 @@ module Parse
           rescue Exception => e
             r = Parse::Response.new
             r.code = response_env.status
-            r.error = "Invalid Parse Response: #{e}"
+            r.error = "Invalid response for #{env[:method]} #{env[:url]}: #{e}"
           end
-
+          r.http_status = response_env[:status]
           r.code ||= response_env[:status] if r.error.present?
           response_env[:body] = r
         end

data/lib/parse/client/request.rb

@@ -10,8 +10,10 @@ module Parse
       def initialize(method, uri, body: nil, headers: nil, opts: {})
         @tag = 0
         method = method.downcase.to_sym
-        raise "Invalid Method type #{method} " unless [:get,:put,:delete,:post].include?(method)
-        self.method = method.downcase
+        unless method == :get || method == :put || method == :post || method == :delete
+          raise "Invalid method #{method} for request : '#{uri}'"
+        end
+        self.method = method
         self.path = uri
         self.body = body
         self.headers = headers || {}
@@ -39,6 +41,14 @@ module Parse
         {method: @method.upcase, path: @path, body: @body}
       end
 
+      def inspect
+          "#<#{self.class} @method=#{@method} @path='#{@path}'>"
+      end
+
+      def to_s
+        "#{@method.to_s.upcase} #{@path}"
+      end
+
   end
 
 end

data/lib/parse/client/response.rb

@@ -9,6 +9,7 @@ module Parse
     include Enumerable
 
     ERROR_INTERNAL = 1
+    ERROR_SERVICE_UNAVAILALBE = 2
     ERROR_TIMEOUT = 124
     ERROR_EXCEEDED_BURST_LIMIT = 155
     ERROR_OBJECT_NOT_FOUND = 101
@@ -18,12 +19,14 @@ module Parse
     RESULTS = "results".freeze
     COUNT = "count".freeze
     # A response has a result or (a code and an error)
-    attr_accessor :parse_class, :code, :error, :result
+    attr_accessor :parse_class, :code, :error, :result, :http_status
+    attr_accessor :request # capture request that created result
     # You can query Parse for counting objects, which may not actually have
     # results.
     attr_reader :count
 
     def initialize(res = {})
+      @http_status = 0
       @count = 0
       @batch_response = false # by default, not a batch response
       @result = nil
@@ -127,8 +130,8 @@ module Parse
     end
 
     def to_s
-      return "E-#{@code}: #{@error}" if error?
-      @result
+      return "[E-#{@code}] #{@request} : #{@error} (#{@http_status})" if error?
+      @result.to_json
     end
 
   end

data/lib/parse/model/model.rb

@@ -68,7 +68,7 @@ module Parse
       return Parse::Date if str == TYPE_DATE.freeze
       # return Parse::User if str == "User".freeze
       # return Parse::Installation if str == "Installation".freeze
-
+      
       str = str.to_s
       # Basically go through all Parse::Object subclasses and see who is has a parse_class
       # set to this string. We will cache the results for future use.

data/lib/parse/query/constraint.rb

@@ -22,7 +22,7 @@ module Parse
       # 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)
+          operation = Operation.new(operation.to_sym, self.class.operand)
       end
       @operation = operation
       @value = value
@@ -30,15 +30,6 @@ module Parse
 
     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
@@ -49,6 +40,18 @@ module Parse
       # The higher the more priority it will receive.
       attr_accessor :precedence
 
+      # Class access to store the default symbol operand action
+      attr_accessor :operand
+
+      # Creates a new constraint given an operation and value.
+      def 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
+
       # method to set the keyword for this Constaint (subclasses)
       def contraint_keyword(k)
         @key = k
@@ -60,6 +63,29 @@ module Parse
         @precedence
       end
 
+      # All subclasses should register their operation and themselves
+      # as the handler.
+      def register(op, klass = self)
+        self.operand ||= op
+        Operation.register op, klass
+      end
+
+      def formatted_value(value)
+        d = value
+        d = { __type: "Date", iso: d.utc.iso8601(3) } if d.respond_to?(:utc)
+        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.to_s if d.is_a?(Regexp)
+        #d = d.pointer if d.is_a?(Parse::Object) #simplified query object
+        #  d = d.compile
+        if d.is_a?(Parse::Query)
+          compiled = d.compile(encode: false, includeClassName: true)
+          # compiled["className"] = d.table
+          d = compiled
+        end
+        d
+      end
+
     end
 
     def precedence
@@ -70,12 +96,6 @@ module Parse
       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
@@ -115,23 +135,10 @@ module Parse
 
     # This method formats the value based on some specific data types.
     def formatted_value
-      d = @value
-      d = { __type: "Date", iso: d.utc.iso8601(3) } if d.respond_to?(:utc)
-      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.to_s if d.is_a?(Regexp)
-      #d = d.pointer if d.is_a?(Parse::Object) #simplified query object
-      #  d = d.compile
-      if d.is_a?(Parse::Query)
-        compiled = d.compile(encode: false, includeClassName: true)
-        # compiled["className"] = d.table
-        d = compiled
-      end
-      d
+      self.class.formatted_value(@value)
     end
 
     register :eq, Constraint
-    register :eql, Constraint
     precedence 100
   end
 end

data/lib/parse/query/constraints.rb

@@ -7,8 +7,38 @@ require_relative 'constraint'
 # 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
+class ParseConstraintError < Exception; end;
 module Parse
 
+  class ObjectIdConstraint < Constraint
+    register :id
+
+
+    def build
+      className = operand.to_parse_class
+      value = formatted_value
+      begin
+        klass = className.constantize
+      rescue NameError => e
+        klass = Parse::Model.find_class className
+      end
+
+      unless klass.present? && klass.is_a?(Parse::Object) == false
+        raise ParseConstraintError, "#{self.class}: No Parse class defined for #{operand} as '#{className}'"
+      end
+
+      # allow symbols
+      value = value.to_s if value.is_a?(Symbol)
+
+      unless value.is_a?(String) && value.strip.present?
+        raise ParseConstraintError, "#{self.class}: value must be of string type representing a Parse object id."
+      end
+      value.strip!
+      return { @operation.operand  => klass.pointer(value) }
+    end
+
+  end
+
   class CompoundQueryConstraint < Constraint
     contraint_keyword :$or
     register :or
@@ -21,7 +51,7 @@ module Parse
 
   end
 
-  class LessOrEqualConstraint < Constraint
+  class LessThanOrEqualConstraint < Constraint
     contraint_keyword :$lte
     register :lte
     register :less_than_or_equal
@@ -42,7 +72,7 @@ module Parse
     register :after
   end
 
-  class GreaterOrEqualConstraint < Constraint
+  class GreaterThanOrEqualConstraint < Constraint
     contraint_keyword :$gte
     register :gte
     register :greater_than_or_equal
@@ -51,22 +81,8 @@ module Parse
 
   class NotEqualConstraint < Constraint
     contraint_keyword :$ne
-    register :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
-
+    register :ne
   end
 
   # Nullabiliity constraint maps $exist Parse clause a bit differently
@@ -81,7 +97,12 @@ module Parse
     def build
       # if nullability is equal true, then $exists should be set to false
 
-      if formatted_value == true
+      value = formatted_value
+      unless value == true || value == false
+        raise ParseConstraintError, "#{self.class}: Non-Boolean value passed, it must be either `true` or `false`"
+      end
+
+      if value == true
         return { @operation.operand => { key => false} }
       else
         #current bug in parse where if you want exists => true with geo queries
@@ -97,15 +118,42 @@ module Parse
     register :exists
     def build
       # if nullability is equal true, then $exists should be set to false
-      return { @operation.operand => { key => formatted_value } }
+      value = formatted_value
+
+      unless value == true || value == false
+        raise ParseConstraintError, "#{self.class}: Non-Boolean value passed, it must be either `true` or `false`"
+      end
+
+      return { @operation.operand => { key => value } }
+    end
+  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
 
   class NotContainedInConstraint < Constraint
     contraint_keyword :$nin
-    register :nin
     register :not_in
+    register :nin
     register :not_contained_in
+
+    def build
+      val = formatted_value
+      val = [val].compact unless val.is_a?(Array)
+      { @operation.operand => { key => val } }
+    end
+
   end
 
   # All Things must be contained
@@ -113,6 +161,12 @@ module Parse
     contraint_keyword :$all
     register :all
     register :contains_all
+
+    def build
+      val = formatted_value
+      val = [val].compact unless val.is_a?(Array)
+      { @operation.operand => { key => val } }
+    end
   end
 
   class SelectionConstraint < Constraint
@@ -158,14 +212,14 @@ module Parse
         remote_field_name = res[:key] || remote_field_name
         query = res[:query]
         unless query.is_a?(Parse::Query)
-          raise "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
+          raise ParseConstraintError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
         end
         query = query.compile(encode: false, includeClassName: true)
       elsif @value.is_a?(Parse::Query)
         # if its a query, then assume dontSelect key is the same name as operand.
         query = @value.compile(encode: false, includeClassName: true)
       else
-        raise "Invalid `:reject` query constraint. It should follow the format: :field.reject => { key: 'key', query: '<Parse::Query>' }"
+        raise ParseConstraintError, "Invalid `:reject` query constraint. It should follow the format: :field.reject => { key: 'key', query: '<Parse::Query>' }"
       end
       { @operation.operand => { :$dontSelect => { key: remote_field_name, query: query } } }
     end
@@ -233,7 +287,7 @@ module Parse
       geopoint_values = formatted_value
       unless geopoint_values.is_a?(Array) && geopoint_values.count == 2 &&
         geopoint_values.first.is_a?(Parse::GeoPoint) && geopoint_values.last.is_a?(Parse::GeoPoint)
-        raise( '[Parse::Query] Invalid query value parameter passed to `within_box` constraint. ' +
+        raise(ParseConstraintError, '[Parse::Query] Invalid query value parameter passed to `within_box` constraint. ' +
                 'Values in array must be `Parse::GeoPoint` objects and ' +
                 'it should be in an array format: [southwestPoint, northeastPoint]' )
       end

data/lib/parse/stack/version.rb

@@ -1,5 +1,5 @@
 module Parse
   module Stack
-    VERSION = "1.3.7"
+    VERSION = "1.3.8"
   end
 end

data/lib/parse/webhooks.rb

@@ -214,7 +214,7 @@ 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}"
+            puts "[ParseWebhooks] --> Could not find mapping route for #{payload.to_json}"
           end
 
           result = true if result.nil?

data/parse-stack.gemspec

@@ -34,15 +34,13 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "faraday", [">= 0.8", "< 1"]
   spec.add_runtime_dependency "faraday_middleware", [">= 0.9", "< 1"]
   spec.add_runtime_dependency "moneta", [">= 0.7", "< 1"]
-  spec.add_runtime_dependency "rack", ["< 3"]
-
-  spec.post_install_message = <<UPGRADE
-
-** IMPORTANT **
- The limit field in a Parse::Query no longer defaults to 100, it must be explicitly set.
-
- Parse::Webhook exception handling has changed in 1.3.0 and later.
- See guide: https://github.com/modernistik/parse-stack/wiki/Webhook-Migration-1.2.x-to-1.3.0
-
-UPGRADE
+  spec.add_runtime_dependency "rack", "< 3"
+
+#   spec.post_install_message = <<UPGRADE
+#
+# ** IMPORTANT **
+#  Parse::Webhook exception handling has changed in 1.3.0 and later.
+#  See guide: https://github.com/modernistik/parse-stack/wiki/Webhook-Migration-1.2.x-to-1.3.0
+#
+# UPGRADE
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 1.3.8
 platform: ruby
 authors:
 - Anthony Persaud
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
+date: 2016-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -238,14 +238,7 @@ homepage: https://github.com/modernistik/parse-stack
 licenses:
 - MIT
 metadata: {}
-post_install_message: |2+
-
-  ** IMPORTANT **
-   The limit field in a Parse::Query no longer defaults to 100, it must be explicitly set.
-
-   Parse::Webhook exception handling has changed in 1.3.0 and later.
-   See guide: https://github.com/modernistik/parse-stack/wiki/Webhook-Migration-1.2.x-to-1.3.0
-
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib