graphql-client 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40e658148a8c85013b801639a0f476c7287db05a
-  data.tar.gz: 47fedb450c1456d4436ec983c11c4fc4000a2c89
+  metadata.gz: c2383236dd4b9c7a7589212a7ec4fa057d0355cb
+  data.tar.gz: 0e858ee34e190846593cadec92238c406b9903dc
 SHA512:
-  metadata.gz: 37ac81a288e27b7f7e283a5ab650908e97a4eac6d4c0c0e839f9ad11d9e6611d2b4a132383f65c81f13065adf115b8de173df252dbbe456c555caf73c72e8fa7
-  data.tar.gz: 2249225df289e023f31be5c41a89a6b3ca8030ed7e2e1298162cb718a74b9dea9dcd7ae43921c071432ad5cc92e11d4b0829b7392c4536454b3e0311fb9652e9
+  metadata.gz: 4fa1b4185938e68e90082eaa6be4ce1c814503b2254aea005c44cfe636f2c2ea358fc97250ef868ad5271e4609359296eb7e18b32a9dbf697b323becea67866d
+  data.tar.gz: 3f3ae9c9a78dddfcc5b8758a072dd173b47d5fe5a1bfa1a853443bebcd5386250a360862ff3c6482a1a40e3671f9664215dbbf7f46351323fdc3401a98ce109a

data/lib/graphql/client.rb

@@ -2,10 +2,10 @@ require "active_support/inflector"
 require "active_support/notifications"
 require "graphql"
 require "graphql/client/error"
+require "graphql/client/errors"
 require "graphql/client/query_result"
 require "graphql/client/response"
 require "graphql/language/nodes/deep_freeze_ext"
-require "graphql/language/operation_slice"
 require "json"
 
 module GraphQL
@@ -203,7 +203,7 @@ module GraphQL
       definitions = {}
       doc.definitions.each do |node|
         node.name = nil if node.name == "__anonymous__"
-        sliced_document = Language::OperationSlice.slice(document_dependencies, node.name)
+        sliced_document = Language::DefinitionSlice.slice(document_dependencies, node.name)
         definition = Definition.for(node: node, document: sliced_document)
         definitions[node.name] = definition
       end
@@ -265,7 +265,16 @@ module GraphQL
         )
       end
 
-      Response.for(definition, result)
+      data, errors, extensions = result.values_at("data", "errors", "extensions")
+
+      errors ||= []
+      GraphQL::Client::Errors.normalize_error_paths(data, errors)
+
+      Response.new(
+        data: definition.new(data, Errors.new(errors, ["data"])),
+        errors: Errors.new(errors),
+        extensions: extensions
+      )
     end
 
     # Internal: FragmentSpread and FragmentDefinition extension to allow its

data/lib/graphql/client/errors.rb

@@ -0,0 +1,200 @@
+require "graphql/client/hash_with_indifferent_access"
+
+module GraphQL
+  class Client
+    # Public: Collection of errors associated with GraphQL object type.
+    #
+    # Inspired by ActiveModel::Errors.
+    class Errors
+      include Enumerable
+
+      # Internal: Normalize GraphQL Error "path" ensuring the path exists.
+      #
+      # Records "normalizedPath" value to error object.
+      #
+      # data - Hash of response data
+      # errors - Array of error Hashes
+      #
+      # Returns nothing.
+      def self.normalize_error_paths(data = nil, errors = [])
+        errors.each do |error|
+          path = ["data"]
+          current = data
+          error.fetch("path", []).each do |key|
+            break unless current
+            path << key
+            current = current[key]
+          end
+          error["normalizedPath"] = path
+        end
+        errors
+      end
+
+      # Internal: Initalize from collection of errors.
+      #
+      # errors - Array of GraphQL Hash error objects
+      # path   - Array of String|Integer fields to data
+      # all    - Boolean flag if all nested errors should be available
+      def initialize(errors = [], path = [], all = false)
+        @ast_path = path
+        @all = all
+        @raw_errors = errors
+      end
+
+      # Public: Return collection of all nested errors.
+      #
+      #   data.errors[:node]
+      #   data.errors.all[:node]
+      #
+      # Returns Errors collection.
+      def all
+        if @all
+          self
+        else
+          self.class.new(@raw_errors, @ast_path, true)
+        end
+      end
+
+      # Internal: Return collection of errors for a given subfield.
+      #
+      #   data.errors.filter_by_path("node")
+      #
+      # Returns Errors collection.
+      def filter_by_path(field)
+        self.class.new(@raw_errors, @ast_path + [field], @all)
+      end
+
+      # Public: Access Hash of error messages.
+      #
+      #   data.errors.messages["node"]
+      #   data.errors.messages[:node]
+      #
+      # Returns HashWithIndifferentAccess.
+      def messages
+        return @messages if defined? @messages
+
+        messages = {}
+
+        details.each do |field, errors|
+          messages[field] ||= []
+          errors.each do |error|
+            messages[field] << error.fetch("message")
+          end
+        end
+
+        @messages = HashWithIndifferentAccess.new(messages)
+      end
+
+      # Public: Access Hash of error objects.
+      #
+      #   data.errors.details["node"]
+      #   data.errors.details[:node]
+      #
+      # Returns HashWithIndifferentAccess.
+      def details
+        return @details if defined? @details
+
+        details = {}
+
+        @raw_errors.each do |error|
+          path = error.fetch("normalizedPath", [])
+          matched_path = @all ? path[0, @ast_path.length] : path[0...-1]
+          next unless @ast_path == matched_path
+
+          field = path[@ast_path.length]
+          next unless field
+
+          details[field] ||= []
+          details[field] << error
+        end
+
+        @details = HashWithIndifferentAccess.new(details)
+      end
+
+      # Public: When passed a symbol or a name of a field, returns an array of
+      # errors for the method.
+      #
+      #   data.errors[:node]  # => ["couldn't find node by id"]
+      #   data.errors['node'] # => ["couldn't find node by id"]
+      #
+      # Returns Array of errors.
+      def [](key)
+        messages.fetch(key, [])
+      end
+
+      # Public: Iterates through each error key, value pair in the error
+      # messages hash. Yields the field and the error for that attribute. If the
+      # field has more than one error message, yields once for each error
+      # message.
+      def each
+        return enum_for(:each) unless block_given?
+        messages.keys.each do |field|
+          messages[field].each { |error| yield field, error }
+        end
+      end
+
+      # Public: Check if there are any errors on a given field.
+      #
+      #   data.errors.messages # => {"node"=>["couldn't find node by id", "unauthorized"]}
+      #   data.errors.include?("node")    # => true
+      #   data.errors.include?("version") # => false
+      #
+      # Returns true if the error messages include an error for the given field,
+      # otherwise false.
+      def include?(field)
+        self[field].any?
+      end
+      alias has_key? include?
+      alias key? include?
+
+      # Public: Count the number of errors on object.
+      #
+      #   data.errors.messages # => {"node"=>["couldn't find node by id", "unauthorized"]}
+      #   data.errors.size     # => 2
+      #
+      # Returns the number of error messages.
+      def size
+        values.flatten.size
+      end
+      alias count size
+
+      # Public: Check if there are no errors on object.
+      #
+      #   data.errors.messages # => {"node"=>["couldn't find node by id"]}
+      #   data.errors.empty?   # => false
+      #
+      # Returns true if no errors are found, otherwise false.
+      def empty?
+        size.zero?
+      end
+      alias blank? empty?
+
+      # Public: Returns all message keys.
+      #
+      #   data.errors.messages # => {"node"=>["couldn't find node by id"]}
+      #   data.errors.values   # => ["node"]
+      #
+      # Returns Array of String field names.
+      def keys
+        messages.keys
+      end
+
+      # Public: Returns all message values.
+      #
+      #   data.errors.messages # => {"node"=>["couldn't find node by id"]}
+      #   data.errors.values   # => [["couldn't find node by id"]]
+      #
+      # Returns Array of Array String messages.
+      def values
+        messages.values
+      end
+
+      # Public: Display console friendly representation of errors collection.
+      #
+      # Returns String.
+      def inspect
+        "#<#{self.class} @messages=#{messages.inspect} @details=#{details.inspect}>"
+      end
+    end
+  end
+end

data/lib/graphql/client/hash_with_indifferent_access.rb

@@ -0,0 +1,57 @@
+require "active_support/inflector"
+
+module GraphQL
+  class Client
+    # Public: Implements a read only hash where keys can be accessed by
+    # strings, symbols, snake or camel case.
+    #
+    # Also see ActiveSupport::HashWithIndifferentAccess.
+    class HashWithIndifferentAccess
+      extend Forwardable
+      include Enumerable
+
+      def initialize(hash = {})
+        @hash = hash
+        @aliases = {}
+
+        hash.keys.each do |key|
+          if key.is_a?(String)
+            key_alias = ActiveSupport::Inflector.underscore(key)
+            @aliases[key_alias] = key if key != key_alias
+          end
+        end
+
+        freeze
+      end
+
+      def_delegators :@hash, :each, :empty?, :inspect, :keys, :length, :size, :to_h, :to_hash, :values
+
+      def [](key)
+        @hash[convert_value(key)]
+      end
+
+      def fetch(key, *args, &block)
+        @hash.fetch(convert_value(key), *args, &block)
+      end
+
+      def key?(key)
+        @hash.key?(convert_value(key))
+      end
+      alias include? key?
+      alias has_key? key?
+      alias member? key?
+
+      private
+
+      def convert_value(key)
+        case key
+        when String, Symbol
+          key = key.to_s
+          @aliases.fetch(key, key)
+        else
+          key
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/list.rb

@@ -0,0 +1,19 @@
+require "graphql/client/errors"
+
+module GraphQL
+  class Client
+    # Public: Array wrapper for value returned from GraphQL List.
+    class List < Array
+      def initialize(values, errors = Errors.new)
+        super(values)
+        @errors = errors
+        freeze
+      end
+
+      # Public: Return errors associated with list of data.
+      #
+      # Returns Errors collection.
+      attr_reader :errors
+    end
+  end
+end

data/lib/graphql/client/query_result.rb

@@ -1,5 +1,7 @@
 require "active_support/inflector"
 require "graphql"
+require "graphql/client/errors"
+require "graphql/client/list"
 require "set"
 
 module GraphQL
@@ -58,18 +60,18 @@ module GraphQL
 
             next unless field == "edges"
             class_eval <<-RUBY, __FILE__, __LINE__
-                def each_node
-                  return enum_for(:each_node) unless block_given?
-                  edges.each { |edge| yield edge.node }
-                  self
-                end
+              def each_node
+                return enum_for(:each_node) unless block_given?
+                edges.each { |edge| yield edge.node }
+                self
+              end
             RUBY
           end
 
           assigns = fields.map do |field, type|
             if type
               <<-RUBY
-                @#{field} = self.class.fields[:#{field}].cast(@data["#{field}"])
+                @#{field} = self.class.fields[:#{field}].cast(@data["#{field}"], @errors.filter_by_path("#{field}"))
               RUBY
             else
               <<-RUBY
@@ -79,8 +81,10 @@ module GraphQL
           end
 
           class_eval <<-RUBY, __FILE__, __LINE__
-            def initialize(data)
+            def initialize(data, errors = Errors.new)
               @data = data
+              @errors = errors
+
               #{assigns.join("\n")}
               freeze
             end
@@ -106,10 +110,10 @@ module GraphQL
         "#<#{name} fields=#{@fields.keys.inspect}>"
       end
 
-      def self.cast(obj)
+      def self.cast(obj, errors = Errors.new)
         case obj
         when Hash
-          new(obj)
+          new(obj, errors)
         when self
           return obj
         when QueryResult
@@ -121,9 +125,9 @@ module GraphQL
             message << GraphQL::Language::Generation.generate(obj.class.source_node).sub(/\n}$/, "#{suggestion}\n}")
             raise TypeError, message
           end
-          cast(obj.to_h)
+          cast(obj.to_h, obj.errors)
         when Array
-          obj.map { |e| cast(e) }
+          List.new(obj.each_with_index.map { |e, idx| cast(e, errors.filter_by_path(idx)) }, errors)
         when NilClass
           nil
         else
@@ -145,12 +149,12 @@ module GraphQL
         end
       end
 
-      def self.new(obj)
+      def self.new(obj, *args)
         case obj
         when Hash
           super
         else
-          cast(obj)
+          cast(obj, *args)
         end
       end
 
@@ -167,6 +171,11 @@ module GraphQL
         define(name: self.name, source_node: source_node, fields: new_fields)
       end
 
+      # Public: Return errors associated with data.
+      #
+      # Returns Errors collection.
+      attr_reader :errors
+
       attr_reader :data
       alias to_h data
 

data/lib/graphql/client/response.rb

@@ -1,4 +1,4 @@
-require "graphql/client/error"
+require "graphql/client/errors"
 
 module GraphQL
   class Client
@@ -6,45 +6,6 @@ module GraphQL
     #
     #   https://facebook.github.io/graphql/#sec-Response-Format
     class Response
-      # Internal: Initialize Response subclass.
-      def self.for(definition, result)
-        data, errors, extensions = result.values_at("data", "errors", "extensions")
-
-        if data && errors
-          PartialResponse.new(
-            data: definition.new(data),
-            errors: ResponseErrors.new(definition, errors),
-            extensions: extensions
-          )
-        elsif data && !errors
-          SuccessfulResponse.new(
-            data: definition.new(data),
-            extensions: extensions
-          )
-        elsif !data && errors
-          FailedResponse.new(
-            errors: ResponseErrors.new(definition, errors),
-            extensions: extensions
-          )
-        else
-          FailedResponse.new(
-            errors: ResponseErrors.new(definition, [{ "message" => "invalid GraphQL response" }])
-          )
-        end
-      end
-
-      # Public: Hash of server specific extension metadata.
-      attr_reader :extensions
-
-      # Internal: Initialize base class.
-      def initialize(extensions: nil)
-        @extensions = extensions || {}
-      end
-    end
-
-    # Public: A successful response means the query executed without any errors
-    # and returned all the requested data.
-    class SuccessfulResponse < Response
       # Public: Wrapped QueryResult of data returned from the server.
       #
       #   https://facebook.github.io/graphql/#sec-Data
@@ -52,89 +13,21 @@ module GraphQL
       # Returns instance of QueryResult subclass.
       attr_reader :data
 
-      # Internal: Initialize SuccessfulResponse.
-      def initialize(data:, **kargs)
-        @data = data
-        super(**kargs)
-      end
-    end
-
-    # Public: A partial response means the query executed with some errors but
-    # returned all non-nullable fields. PartialResponse is still considered a
-    # SuccessfulResponse as it returns data and the client may still proceed
-    # with its normal render flow.
-    class PartialResponse < SuccessfulResponse
       # Public: Get partial failures from response.
       #
       #   https://facebook.github.io/graphql/#sec-Errors
       #
-      # Returns ResponseErrors collection object with zero or more errors.
+      # Returns Errors collection object with zero or more errors.
       attr_reader :errors
 
-      # Internal: Initialize PartialResponse.
-      def initialize(errors:, **kargs)
-        @errors = errors
-        super(**kargs)
-      end
-    end
-
-    # Public: A failed response returns no data and at least one error message.
-    # Cases may likely be a query validation error, missing authorization,
-    # or internal server crash.
-    class FailedResponse < Response
-      # Public: Get errors from response.
-      #
-      #   https://facebook.github.io/graphql/#sec-Errors
-      #
-      # Returns ResponseErrors collection object with one or more errors.
-      attr_reader :errors
+      # Public: Hash of server specific extension metadata.
+      attr_reader :extensions
 
-      # Internal: Initialize FailedResponse.
-      def initialize(errors:, **kargs)
+      # Internal: Initialize base class.
+      def initialize(data: nil, errors: Errors.new, extensions: {})
+        @data = data
         @errors = errors
-        super(**kargs)
-      end
-    end
-
-    # Public: An error received from the server on execution.
-    #
-    # Extends StandardError hierarchy so you may raise this instance.
-    #
-    # Examples
-    #
-    #   raise response.errors.first
-    #
-    class ResponseError < Error
-      # Internal: Initialize ResponseError.
-      def initialize(definition, error)
-        @request_definition = definition
-        @locations = error["locations"]
-        super error["message"]
-      end
-    end
-
-    # Public: A collection of errors received from the server on execution.
-    #
-    # Extends StandardError hierarchy so you may raise this instance.
-    #
-    # Examples
-    #
-    #   raise response.errors
-    #
-    class ResponseErrors < Error
-      include Enumerable
-
-      attr_reader :errors
-
-      # Internal: Initialize ResponseErrors.
-      def initialize(definition, errors)
-        @request_definition = definition
-        @errors = errors.map { |error| ResponseError.new(definition, error) }
-        super @errors.map(&:message).join(", ")
-      end
-
-      def each(&block)
-        errors.each(&block)
+        @extensions = extensions
       end
     end
   end

data/lib/graphql/language/nodes/deep_freeze_ext.rb

@@ -12,6 +12,12 @@ module GraphQL
           self.class.child_attributes.each do |attr_name|
             public_send(attr_name).freeze.each(&:deep_freeze)
           end
+
+          self.class.scalar_attributes.each do |attr_name|
+            object = public_send(attr_name)
+            object.freeze if object
+          end
+
           freeze
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-07 00:00:00.000000000 Z
+date: 2016-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -36,20 +36,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.11
+        version: 0.19.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.11
+        version: 0.19.2
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -122,15 +122,17 @@ files:
 - README.md
 - lib/graphql/client.rb
 - lib/graphql/client/error.rb
+- lib/graphql/client/errors.rb
 - lib/graphql/client/erubis.rb
+- lib/graphql/client/hash_with_indifferent_access.rb
 - lib/graphql/client/http.rb
+- lib/graphql/client/list.rb
 - lib/graphql/client/log_subscriber.rb
 - lib/graphql/client/query_result.rb
 - lib/graphql/client/railtie.rb
 - lib/graphql/client/response.rb
 - lib/graphql/client/view_module.rb
 - lib/graphql/language/nodes/deep_freeze_ext.rb
-- lib/graphql/language/operation_slice.rb
 homepage: https://github.com/github/graphql-client
 licenses:
 - MIT

data/lib/graphql/language/operation_slice.rb

@@ -1,44 +0,0 @@
-require "graphql"
-
-module GraphQL
-  module Language
-    # Public: Document transformations to return a minimal document to represent
-    # operation.
-    module OperationSlice
-      # Public: Return's minimal document to represent operation.
-      #
-      # Find's target operation and any fragment dependencies and returns a
-      # new document with just those definitions.
-      #
-      # document - The Nodes::Document to find definitions.
-      # operation_name - The String name of Nodes::OperationDefinition
-      #
-      # Returns new Nodes::Document.
-      def self.slice(document, operation_name)
-        seen = Set.new([operation_name])
-        stack = [operation_name]
-
-        until stack.empty?
-          name = stack.pop
-          names = find_definition_fragment_spreads(document, name)
-          seen.merge(names)
-          stack.concat(names.to_a)
-        end
-
-        Nodes::Document.new(definitions: document.definitions.select { |node| seen.include?(node.name) })
-      end
-
-      def self.find_definition_fragment_spreads(document, definition_name)
-        definition = document.definitions.find { |node| node.name == definition_name }
-        raise "missing definition: #{definition_name}" unless definition
-        spreads = Set.new
-        visitor = Visitor.new(definition)
-        visitor[Nodes::FragmentSpread].enter << -> (node, _parent) do
-          spreads << node.name
-        end
-        visitor.visit
-        spreads
-      end
-    end
-  end
-end