graphql 0.18.13 → 0.18.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ede8bf16e041625d9150b4a02ca1203e5f77f67
-  data.tar.gz: be963dcb88acc294fd826798a1d1e480d3abb8f1
+  metadata.gz: d8692b90c4aa941fe5a1139719790eb1ba55c92e
+  data.tar.gz: 84c924ce93a593f26a7419f9ed69e5220380201c
 SHA512:
-  metadata.gz: 6e440fc7cc28cf50d1817e5a7bf9d04b3a4e0cb7fc85708f8b7820b1a239305494015e487fbfd3417e24cfe3198ee40507daa709e66267913569f08f7df94a4a
-  data.tar.gz: c3f9943e6016f805f6f2340065ab703c30d96b8130be5369b6095814f6c68b248d4a586dda1a35d9554294ba449698ac18a0e4817b4402a103f69752efe481bc
+  metadata.gz: 26a2968e15530d07b78b293f41bc103fdc3026036de39fd84e0f48434659d23558d806e67b7d07288cd5eb9b6f08cfbb06e76d809b865d35c70355cd7ad51ae7
+  data.tar.gz: 9c3401de8f427e468db33e2403b729ec5ccc291b53e95d8d853ef86e28744cfec291c5df778f34c8497149d82f4aa3054ddb0ff8059516e973f0fbc2441e999d

data/lib/graphql/analysis.rb

@@ -2,5 +2,6 @@ require "graphql/analysis/max_query_complexity"
 require "graphql/analysis/max_query_depth"
 require "graphql/analysis/query_complexity"
 require "graphql/analysis/query_depth"
+require "graphql/analysis/reducer_state"
 require "graphql/analysis/analyze_query"
 require "graphql/analysis/field_usage"

data/lib/graphql/analysis/analyze_query.rb

@@ -13,15 +13,15 @@ module GraphQL
     # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
     # @return [Array<Any>] Results from those analyzers
     def analyze_query(query, analyzers)
-      analyzers_and_values = analyzers.map { |r| initialize_reducer(r, query) }
+      reducer_states = analyzers.map { |r| ReducerState.new(r, query) }
 
       irep = query.internal_representation
 
       irep.each do |name, op_node|
-        reduce_node(op_node, analyzers_and_values)
+        reduce_node(op_node, reducer_states)
       end
 
-      analyzers_and_values.map { |(r, value)| finalize_reducer(r, value) }
+      reducer_states.map { |r| r.finalize_reducer }
     end
 
     private
@@ -29,44 +29,21 @@ module GraphQL
     module_function
 
     # Enter the node, visit its children, then leave the node.
-    def reduce_node(irep_node, analyzers_and_values)
-      visit_analyzers(:enter, irep_node, analyzers_and_values)
+    def reduce_node(irep_node, reducer_states)
+      visit_analyzers(:enter, irep_node, reducer_states)
 
       irep_node.children.each do |name, child_irep_node|
-        reduce_node(child_irep_node, analyzers_and_values)
+        reduce_node(child_irep_node, reducer_states)
       end
 
-      visit_analyzers(:leave, irep_node, analyzers_and_values)
+      visit_analyzers(:leave, irep_node, reducer_states)
     end
 
-    def visit_analyzers(visit_type, irep_node, analyzers_and_values)
-      analyzers_and_values.each do |reducer_and_value|
-        reducer = reducer_and_value[0]
-        memo = reducer_and_value[1]
-        next_memo = reducer.call(memo, visit_type, irep_node)
-        reducer_and_value[1] = next_memo
-      end
-    end
-
-    # If the reducer has an `initial_value` method, call it and store
-    # the result as `memo`. Otherwise, use `nil` as memo.
-    # @return [Array<(#call, Any)>] reducer-memo pairs
-    def initialize_reducer(reducer, query)
-      if reducer.respond_to?(:initial_value)
-        [reducer, reducer.initial_value(query)]
-      else
-        [reducer, nil]
-      end
-    end
+    def visit_analyzers(visit_type, irep_node, reducer_states)
+      reducer_states.each do |reducer_state|
+        next_memo = reducer_state.call(visit_type, irep_node)
 
-    # If the reducer accepts `final_value`, send it the last memo value.
-    # Otherwise, use the last value from the traversal.
-    # @return [Any] final memo value
-    def finalize_reducer(reducer, reduced_value)
-      if reducer.respond_to?(:final_value)
-        reducer.final_value(reduced_value)
-      else
-        reduced_value
+        reducer_state.memo = next_memo
       end
     end
   end

data/lib/graphql/analysis/reducer_state.rb

@@ -0,0 +1,47 @@
+module GraphQL
+  module Analysis
+    class ReducerState
+      attr_reader :reducer
+      attr_accessor :memo, :errors
+
+      def initialize(reducer, query)
+        @reducer = reducer
+        @memo = initialize_reducer(reducer, query)
+        @errors = []
+      end
+
+      def call(visit_type, irep_node)
+        @memo = @reducer.call(@memo, visit_type, irep_node)
+      rescue AnalysisError => err
+        @errors << err
+      end
+
+      # Respond with any errors, if found. Otherwise, if the reducer accepts
+      # `final_value`, send it the last memo value.
+      # Otherwise, use the last value from the traversal.
+      # @return [Any] final memo value
+      def finalize_reducer
+        if @errors.any?
+          @errors
+        elsif reducer.respond_to?(:final_value)
+          reducer.final_value(@memo)
+        else
+          @memo
+        end
+      end
+
+      private
+
+      # If the reducer has an `initial_value` method, call it and store
+      # the result as `memo`. Otherwise, use `nil` as memo.
+      # @return [Any] initial memo value
+      def initialize_reducer(reducer, query)
+        if reducer.respond_to?(:initial_value)
+          reducer.initial_value(query)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution_error.rb

@@ -6,6 +6,11 @@ module GraphQL
     # @return [GraphQL::Language::Nodes::Field] the field where the error occured
     attr_accessor :ast_node
 
+    def initialize(message, ast_node: nil)
+      @ast_node = ast_node
+      super(message)
+    end
+
     # @return [Hash] An entry for the response's "errors" key
     def to_h
       hash = {

data/lib/graphql/query.rb

@@ -182,7 +182,10 @@ module GraphQL
       @analysis_errors = begin
         if @query_analyzers.any?
           reduce_results = GraphQL::Analysis.analyze_query(self, @query_analyzers)
-          reduce_results.select { |r| r.is_a?(GraphQL::AnalysisError) }.map(&:to_h)
+          reduce_results
+          .flatten # accept n-dimensional array
+          .select { |r| r.is_a?(GraphQL::AnalysisError) }
+          .map(&:to_h)
         else
           []
         end

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -13,33 +13,34 @@ module GraphQL
         visitor[GraphQL::Language::Nodes::Document].leave << -> (node, parent) {
           has_selections.each { |node|
             field_map = gather_fields_by_name(node.selections, {}, [], context)
-            find_conflicts(field_map, context)
+            find_conflicts(field_map, [], context)
           }
         }
       end
 
       private
 
-      def find_conflicts(field_map, context)
+      def find_conflicts(field_map, visited_fragments, context)
         field_map.each do |name, ast_fields|
           comparison = FieldDefinitionComparison.new(name, ast_fields, context)
           context.errors.push(*comparison.errors)
 
 
           subfield_map = {}
-          visited_fragments = []
           ast_fields.each do |defn|
             gather_fields_by_name(defn.selections, subfield_map, visited_fragments, context)
           end
-          find_conflicts(subfield_map, context)
+
+          find_conflicts(subfield_map, visited_fragments, context)
         end
       end
 
       def gather_fields_by_name(fields, field_map, visited_fragments, context)
         fields.each do |field|
-          if field.is_a?(GraphQL::Language::Nodes::InlineFragment)
+          case field
+          when GraphQL::Language::Nodes::InlineFragment
             next_fields = field.selections
-          elsif field.is_a?(GraphQL::Language::Nodes::FragmentSpread)
+          when GraphQL::Language::Nodes::FragmentSpread
             if visited_fragments.include?(field.name)
               next
             else
@@ -47,11 +48,13 @@ module GraphQL
             end
             fragment_defn = context.fragments[field.name]
             next_fields = fragment_defn ? fragment_defn.selections : []
-          else
+          when GraphQL::Language::Nodes::Field
             name_in_selection = field.alias || field.name
             field_map[name_in_selection] ||= []
             field_map[name_in_selection].push(field)
             next_fields = []
+          else
+            raise "Unexpected field for merging: #{field}"
           end
           gather_fields_by_name(next_fields, field_map, visited_fragments, context)
         end
@@ -76,16 +79,6 @@ module GraphQL
             errors << message("Field '#{name}' has an argument conflict: #{args.map {|a| JSON.dump(a) }.join(" or ")}?", defs.first, context: context)
           end
 
-          directive_names = defs.map { |defn| defn.directives.map(&:name) }.uniq
-          if directive_names.length != 1
-            errors << message("Field '#{name}' has a directive conflict: #{directive_names.map {|names| "[#{names.join(", ")}]"}.join(" or ")}?", defs.first, context: context)
-          end
-
-          directive_args = defs.map {|defn| defn.directives.map {|d| reduce_list(d.arguments) } }.uniq
-          if directive_args.length != 1
-            errors << message("Field '#{name}' has a directive argument conflict: #{directive_args.map {|args| JSON.dump(args)}.join(" or ")}?", defs.first, context: context)
-          end
-
           @errors = errors
         end
 

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.18.13"
+  VERSION = "0.18.14"
 end

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -84,9 +84,11 @@ describe GraphQL::Analysis do
             if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
               irep_node.definitions.each do |type_defn, field_defn|
                 if field_defn.resolve_proc.is_a?(GraphQL::Relay::ConnectionResolve)
-                  memo["connection"] += 1
+                  memo[:connection] ||= 0
+                  memo[:connection] += 1
                 else
-                  memo["field"] += 1
+                  memo[:field] ||= 0
+                  memo[:field] += 1
                 end
               end
             end
@@ -109,11 +111,105 @@ describe GraphQL::Analysis do
       it "knows which fields are connections" do
         connection_counts = reduce_result.first
         expected_connection_counts = {
-          "field" => 5,
-          "connection" => 2
+          :field => 5,
+          :connection => 2
         }
         assert_equal expected_connection_counts, connection_counts
       end
     end
   end
+
+  describe ".visit_analyzers" do
+    class IdCatcher
+      def call(memo, visit_type, irep_node)
+        if visit_type == :enter
+          if irep_node.ast_node.name == "id"
+            raise GraphQL::AnalysisError.new("Don't use the id field.", ast_node: irep_node.ast_node)
+          end
+        end
+        memo
+      end
+    end
+
+    class FlavorCatcher
+      def initial_value(query)
+        {
+          :errors => []
+        }
+      end
+
+      def call(memo, visit_type, irep_node)
+        if visit_type == :enter
+          if irep_node.ast_node.name == "flavor"
+            memo[:errors] << GraphQL::AnalysisError.new("Don't use the flavor field.", ast_node: irep_node.ast_node)
+          end
+        end
+        memo
+      end
+
+      def final_value(memo)
+        memo[:errors]
+      end
+    end
+
+    let(:id_catcher) { IdCatcher.new }
+    let(:flavor_catcher) { FlavorCatcher.new }
+    let(:analyzers) { [id_catcher, flavor_catcher] }
+    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
+    let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+    let(:query_string) {%|
+      {
+        cheese(id: 1) {
+          id
+          flavor
+        }
+      }
+    |}
+    let(:schema) { DummySchema }
+    let(:result) { schema.execute(query_string) }
+    let(:query_string) {%|
+      {
+        cheese(id: 1) {
+          id
+          flavor
+        }
+      }
+    |}
+
+    before do
+      @previous_query_analyzers = DummySchema.query_analyzers.dup
+      DummySchema.query_analyzers.clear
+      DummySchema.query_analyzers << id_catcher << flavor_catcher
+    end
+
+    after do
+      DummySchema.query_analyzers.clear
+      DummySchema.query_analyzers.push(*@previous_query_analyzers)
+    end
+
+    it "groups all errors together" do
+      data = result["data"]
+      errors = result["errors"]
+
+      id_error_hash = errors[0]
+      flavor_error_hash = errors[1]
+
+      id_error_response = {
+        "message"=>"Don't use the id field.",
+        "locations"=>[{"line"=>4, "column"=>11}]
+      }
+      flavor_error_response = {
+        "message"=>"Don't use the flavor field.",
+        "locations"=>[{"line"=>5, "column"=>11}]
+      }
+
+      assert_nil data
+
+      assert_equal id_error_response["message"], id_error_hash["message"]
+      assert_equal id_error_response["locations"], id_error_hash["locations"]
+
+      assert_equal flavor_error_response["message"], flavor_error_hash["message"]
+      assert_equal flavor_error_response["locations"], flavor_error_hash["locations"]
+    end
+  end
 end

data/spec/graphql/static_validation/rules/fields_will_merge_spec.rb

@@ -36,8 +36,6 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
 
   it "finds field naming conflicts" do
     expected_errors = [
-      "Field 'id' has a directive conflict: [] or [someFlag]?",                 # different directives
-      "Field 'id' has a directive argument conflict: [] or [{}]?",              # not sure this is a great way to handle it but here we are!
       "Field 'nickname' has a field conflict: name or fatContent?",             # alias conflict in query
       "Field 'fatContent' has a field conflict: fatContent or name?",           # alias/name conflict in query and fragment
       "Field 'similarCheese' has an argument conflict: {\"source\":\"sourceVar\"} or {\"source\":\"SHEEP\"}?", # different arguments

data/spec/graphql/static_validation/rules/fragments_are_finite_spec.rb

@@ -20,7 +20,9 @@ describe GraphQL::StaticValidation::FragmentsAreFinite do
     fragment flavorField on Cheese {
       flavor,
       similarCheese {
-        ... sourceField
+        ... on Cheese {
+          ... sourceField
+        }
       }
     }
     fragment idField on Cheese {

data/spec/graphql/static_validation/validator_spec.rb

@@ -48,6 +48,37 @@ describe GraphQL::StaticValidation::Validator do
       it "handles infinite fragment spreads" do
         assert_equal(1, errors.length)
       end
+
+      describe "nested spreads" do
+        let(:query_string) {%|
+        {
+          allEdible {
+            ... on Cheese {
+              ... cheeseFields
+            }
+          }
+        }
+
+        fragment cheeseFields on Cheese {
+          similarCheese(source: COW) {
+            similarCheese(source: COW) {
+              ... cheeseFields
+            }
+          }
+        }
+        |}
+
+        it "finds an error on the nested spread" do
+          expected = [
+            {
+              "message"=>"Fragment cheeseFields contains an infinite loop",
+              "locations"=>[{"line"=>10, "column"=>9}],
+              "path"=>["fragment cheeseFields"]
+            }
+          ]
+          assert_equal(expected, errors)
+        end
+      end
     end
 
     describe "fragment spreads with no selections" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.18.13
+  version: 0.18.14
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-19 00:00:00.000000000 Z
+date: 2016-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -251,6 +251,7 @@ files:
 - lib/graphql/analysis/max_query_depth.rb
 - lib/graphql/analysis/query_complexity.rb
 - lib/graphql/analysis/query_depth.rb
+- lib/graphql/analysis/reducer_state.rb
 - lib/graphql/analysis_error.rb
 - lib/graphql/argument.rb
 - lib/graphql/base_type.rb