graphql 0.16.1 → 0.17.0

data/lib/graphql/language/parser.y

@@ -169,7 +169,15 @@ rule
   object_value_field:
       name COLON input_value { return make_node(:Argument, name: val[0], value: val[2], position_source: val[0])}
 
-  enum_value: IDENTIFIER { return make_node(:Enum, name: val[0], position_source: val[0])}
+  enum_value: enum_name { return make_node(:Enum, name: val[0], position_source: val[0])}
+
+  enum_name: /* any identifier, but not "true", "false" or "null" */
+      IDENTIFIER
+    | FRAGMENT
+    | ON
+    | QUERY
+    | MUTATION
+    | SUBSCRIPTION
 
   directives_list_opt:
       /* none */      { return [] }

data/lib/graphql/object_type.rb

@@ -22,10 +22,9 @@ module GraphQL
   #
   class ObjectType < GraphQL::BaseType
     accepts_definitions :interfaces, field: GraphQL::Define::AssignObjectField
-    attr_accessor :name, :description
 
     # @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
-    attr_accessor :fields
+    lazy_defined_attr_accessor :fields
 
     def initialize
       @fields = {}
@@ -40,6 +39,7 @@ module GraphQL
 
     def interfaces
       @clean_interfaces ||= begin
+        ensure_defined
         @dirty_interfaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
       rescue
         @dirty_interfaces

data/lib/graphql/query.rb

@@ -51,7 +51,7 @@ module GraphQL
         end
       end
 
-      @arguments_cache = {}
+      @arguments_cache = Hash.new { |h, k| h[k] = {} }
     end
 
     # Get the result for this query, executing it once
@@ -103,11 +103,11 @@ module GraphQL
 
     # Node-level cache for calculating arguments. Used during execution and query analysis.
     # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
-    def arguments_for(irep_node)
-      @arguments_cache[irep_node] ||= begin
+    def arguments_for(irep_node, definition)
+      @arguments_cache[irep_node][definition] ||= begin
         GraphQL::Query::LiteralInput.from_arguments(
           irep_node.ast_node.arguments,
-          irep_node.definition.arguments,
+          definition.arguments,
           self.variables
         )
       end

data/lib/graphql/query/directive_resolution.rb

@@ -3,8 +3,8 @@ module GraphQL
     module DirectiveResolution
       def self.include_node?(irep_node, query)
         irep_node.directives.each do |directive_node|
-          directive_defn = directive_node.definition
-          args = query.arguments_for(directive_node)
+          directive_defn = directive_node.definitions.first
+          args = query.arguments_for(directive_node, directive_defn)
           if !directive_defn.include?(args)
             return false
           end

data/lib/graphql/query/serial_execution/execution_context.rb

@@ -18,8 +18,9 @@ module GraphQL
           @query.fragments[name]
         end
 
-        def get_field(type, name)
-          @schema.get_field(type, name)
+        def get_field(type, irep_node)
+          # fall back for dynamic fields (eg __typename)
+          irep_node.definitions[type] || @schema.get_field(type, irep_node.definition_name) || raise("No field found on #{type.name} for '#{irep_node.definition_name}' (#{irep_node.ast_node.name})")
         end
 
         def add_error(err)

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -9,11 +9,8 @@ module GraphQL
           @parent_type = parent_type
           @target = target
           @execution_context = execution_context
-          @field = execution_context.get_field(parent_type, irep_node.definition.name)
-          if @field.nil?
-            raise("No field found on #{parent_type.name} '#{parent_type}' for '#{ast_node.name}'")
-          end
-          @arguments = execution_context.query.arguments_for(irep_node)
+          @field = execution_context.get_field(parent_type, irep_node)
+          @arguments = execution_context.query.arguments_for(irep_node, @field)
         end
 
         def result

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -32,7 +32,7 @@ module GraphQL
         end
 
         def applies_to_type?(irep_node, type, target)
-          irep_node.on_types.any? { |child_type|
+          irep_node.definitions.any? { |child_type, field_defn|
             GraphQL::Query::TypeResolver.new(target, child_type, type, execution_context.query.context).type
           }
         end

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -57,7 +57,7 @@ module GraphQL
             resolved_type = field_type.resolve_type(value, execution_context)
 
             unless resolved_type.is_a?(GraphQL::ObjectType)
-              raise GraphQL::ObjectType::UnresolvedTypeError.new(irep_node.definition.name, field_type, parent_type)
+              raise GraphQL::ObjectType::UnresolvedTypeError.new(irep_node.definition_name, field_type, parent_type)
             end
 
             strategy_class = get_strategy_for_kind(resolved_type.kind)
@@ -82,7 +82,7 @@ module GraphQL
           # Get the "wrapped" type and resolve the value according to that type
           def result
             if value.nil? || value.is_a?(GraphQL::ExecutionError)
-              raise GraphQL::InvalidNullError.new(irep_node.definition.name, value)
+              raise GraphQL::InvalidNullError.new(irep_node.definition_name, value)
             else
               wrapped_type = field_type.of_type
               strategy_class = get_strategy_for_kind(wrapped_type.kind)

data/lib/graphql/scalar_type.rb

@@ -27,6 +27,7 @@ module GraphQL
     end
 
     def coerce_non_null_input(value)
+      ensure_defined
       @coerce_input_proc.call(value)
     end
 
@@ -37,6 +38,7 @@ module GraphQL
     end
 
     def coerce_result(value)
+      ensure_defined
       @coerce_result_proc.call(value)
     end
 

data/lib/graphql/schema/timeout_middleware.rb

@@ -33,6 +33,7 @@ module GraphQL
 
       def call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
         timeout_at = query_context[@context_key] ||= Time.now + @max_seconds
+
         if timeout_at < Time.now
           on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
         else

data/lib/graphql/string_type.rb

@@ -1,5 +1,7 @@
 GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
   name "String"
+  description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
+
   coerce_result -> (value) { value.to_s }
   coerce_input -> (value) { value.is_a?(String) ? value : nil }
 end

data/lib/graphql/union_type.rb

@@ -11,7 +11,6 @@ module GraphQL
   #
   class UnionType < GraphQL::BaseType
     include GraphQL::BaseType::HasPossibleTypes
-    attr_accessor :name, :description
     accepts_definitions :possible_types, :resolve_type
 
     def kind
@@ -29,6 +28,7 @@ module GraphQL
 
     def possible_types
       @clean_possible_types ||= begin
+        ensure_defined
         @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
       rescue
         @dirty_possible_types

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.16.1"
+  VERSION = "0.17.0"
 end

data/readme.md

@@ -127,9 +127,7 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - Problem: how does a field know which schema to look up the name from?
   - Problem: how can we load types in Rails without accessing the constant?
   - Maybe support by third-party library? `type("Post!")` could implement "type_missing", keeps `graphql-ruby` very simple
-- If we eval'd `define { ... }` blocks _lazily_, would that work around all circular dependency issues?
-- `QueryComplexity` improvements:
-  - Better detection of union / interface possibilities? Right now they're summed
 - Type check improvements:
   - Use catch-all type/field/argument definitions instead of terminating traversal
   - Reduce ad-hoc traversals?
+- Merge `graphql-relay-ruby` into this Repo so that they can stay in sync?

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -191,28 +191,47 @@ describe GraphQL::Analysis::QueryComplexity do
   describe "custom complexities" do
     let(:query) { GraphQL::Query.new(complexity_schema, query_string) }
     let(:complexity_schema) {
-      complexity_type = GraphQL::ObjectType.define do
-        name "Complexity"
+      complexity_interface = GraphQL::InterfaceType.define do
+        name "ComplexityInterface"
+        field :value, types.Int
+      end
+
+      single_complexity_type = GraphQL::ObjectType.define do
+        name "SingleComplexity"
         field :value, types.Int, complexity: 0.1 do
           resolve -> (obj, args, ctx) { obj }
         end
-        field :complexity, -> { complexity_type } do
+        field :complexity, single_complexity_type do
           argument :value, types.Int
           complexity -> (ctx, args, child_complexity) { args[:value] + child_complexity }
           resolve -> (obj, args, ctx) { args[:value] }
         end
+        interfaces [complexity_interface]
+      end
+
+      double_complexity_type = GraphQL::ObjectType.define do
+        name "DoubleComplexity"
+        field :value, types.Int, complexity: 4 do
+          resolve -> (obj, args, ctx) { obj }
+        end
+        interfaces [complexity_interface]
       end
 
       query_type = GraphQL::ObjectType.define do
         name "Query"
-        field :complexity, -> { complexity_type } do
+        field :complexity, single_complexity_type do
           argument :value, types.Int
           complexity -> (ctx, args, child_complexity) { args[:value] + child_complexity }
           resolve -> (obj, args, ctx) { args[:value] }
         end
+
+        field :innerComplexity, complexity_interface do
+          argument :value, types.Int
+          resolve -> (obj, args, ctx) { args[:value] }
+        end
       end
 
-      GraphQL::Schema.new(query: query_type)
+      GraphQL::Schema.new(query: query_type, types: [double_complexity_type])
     }
     let(:query_string) {%|
       {
@@ -231,5 +250,22 @@ describe GraphQL::Analysis::QueryComplexity do
       # 10 from `complexity`, `0.3` from `value`
       assert_equal complexities, [query, 10.3]
     end
+
+    describe "same field on multiple types" do
+      let(:query_string) {%|
+      {
+        innerComplexity(value: 2) {
+          ... on SingleComplexity { value }
+          ... on DoubleComplexity { value }
+        }
+      }
+      |}
+
+      it "picks them max for those fields" do
+        reduce_result
+        # 1 for innerComplexity + 4 for DoubleComplexity.value
+        assert_equal complexities, [query, 5]
+      end
+    end
   end
 end

data/spec/graphql/define/instance_definable_spec.rb

@@ -10,12 +10,12 @@ module Garden
   end
 
   class Vegetable
-    attr_accessor :name, :start_planting_on, :end_planting_on
     include GraphQL::Define::InstanceDefinable
+    lazy_defined_attr_accessor :name, :start_planting_on, :end_planting_on
     accepts_definitions :name, plant_between: DefinePlantBetween
 
     # definition added later:
-    attr_accessor :height
+    lazy_defined_attr_accessor :height
   end
 end
 

data/spec/graphql/field_spec.rb

@@ -89,4 +89,22 @@ describe GraphQL::Field do
       assert_equal "QueryType is invalid: field :symbol_name name must return String, not Symbol (:symbol_name)", err.message
     end
   end
+
+  describe "#hash_key" do
+    let(:source_field) { MilkType.get_field("source") }
+    after { source_field.hash_key = :source }
+
+    it "looks up a value with obj[hash_key]" do
+      resolved_source = source_field.resolve({source: "Abc", "source" => "Xyz"}, nil, nil)
+      assert_equal :source, source_field.hash_key
+      assert_equal "Abc", resolved_source
+    end
+
+    it "can be reassigned" do
+      source_field.hash_key = "source"
+      resolved_source = source_field.resolve({source: "Abc", "source" => "Xyz"}, nil, nil)
+      assert_equal "source", source_field.hash_key
+      assert_equal "Xyz", resolved_source
+    end
+  end
 end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -26,12 +26,12 @@ describe GraphQL::InternalRepresentation::Rewrite do
       assert_equal QueryType, op_node.return_type
       first_field = op_node.children.values.first
       assert_equal 3, first_field.children.length
-      assert_equal [QueryType], first_field.on_types.to_a
+      assert_equal [QueryType], first_field.definitions.keys
       assert_equal CheeseType, first_field.return_type
 
       second_field = op_node.children.values.last
       assert_equal 1, second_field.children.length
-      assert_equal [QueryType], second_field.on_types.to_a
+      assert_equal [QueryType], second_field.definitions.keys
       assert_equal CheeseType, second_field.return_type
     end
   end
@@ -48,7 +48,8 @@ describe GraphQL::InternalRepresentation::Rewrite do
     it "gets dynamic field definitions" do
       cheese_field = rewrite_result[nil].children["cheese"]
       typename_field = cheese_field.children["typename"]
-      assert_equal "__typename", typename_field.definition.name
+      assert_equal "__typename", typename_field.definitions.values.first.name
+      assert_equal "__typename", typename_field.definition_name
     end
   end
 
@@ -112,9 +113,9 @@ describe GraphQL::InternalRepresentation::Rewrite do
       similar_sheep_field = similar_cow_field.children["similarCheese"]
       assert_equal ["flavor", "source"], similar_sheep_field.children.keys
 
-      assert_equal Set.new([EdibleInterface]), cheese_field.children["origin"].on_types
-      assert_equal Set.new([CheeseType, EdibleInterface]), cheese_field.children["fatContent"].on_types
-      assert_equal Set.new([CheeseType]), cheese_field.children["flavor"].on_types
+      assert_equal [EdibleInterface], cheese_field.children["origin"].definitions.keys
+      assert_equal [CheeseType, EdibleInterface], cheese_field.children["fatContent"].definitions.keys
+      assert_equal [CheeseType], cheese_field.children["flavor"].definitions.keys
     end
   end
 end

data/spec/graphql/language/parser_spec.rb

@@ -190,6 +190,7 @@ describe GraphQL::Language::Parser do
               array: [7, 8, 9]
               object: {a: [1,2,3], b: {c: "4"}}
               unicode_bom: "\xef\xbb\xbfquery"
+              keywordEnum: on
             )
           }
         |}
@@ -234,6 +235,10 @@ describe GraphQL::Language::Parser do
           obj = inputs[7].value
           assert_equal %|\xef\xbb\xbfquery|, inputs[7].value
         end
+
+        it "parses enum 'on''" do
+          assert_equal "on", inputs[8].value.name
+        end
       end
     end
 

data/spec/graphql/query/serial_execution/execution_context_spec.rb

@@ -39,7 +39,8 @@ describe GraphQL::Query::SerialExecution::ExecutionContext do
 
   describe "get_field" do
     it "returns the respective field from the schema" do
-      field = execution_context.get_field(DairyType, "cheese")
+      irep_node = OpenStruct.new(definition_name: "cheese", definitions: {DairyType => DairyType.fields["cheese"]})
+      field = execution_context.get_field(DairyType, irep_node)
       assert_equal("cheese", field.name)
     end
   end

data/spec/graphql/schema/timeout_middleware_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::Schema::TimeoutMiddleware do
-  let(:max_seconds) { 2 }
-  let(:timeout_middleware) {  GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2) }
+  let(:max_seconds) { 1 }
+  let(:timeout_middleware) {  GraphQL::Schema::TimeoutMiddleware.new(max_seconds: max_seconds) }
   let(:timeout_schema) {
 
     sleep_for_seconds_resolve = -> (obj, args, ctx) {
@@ -45,18 +45,18 @@ describe GraphQL::Schema::TimeoutMiddleware do
   describe "timeout part-way through" do
     let(:query_string) {%|
       {
-        a: sleepFor(seconds: 0.7)
-        b: sleepFor(seconds: 0.7)
-        c: sleepFor(seconds: 0.7)
-        d: sleepFor(seconds: 0.7)
-        e: sleepFor(seconds: 0.7)
+        a: sleepFor(seconds: 0.4)
+        b: sleepFor(seconds: 0.4)
+        c: sleepFor(seconds: 0.4)
+        d: sleepFor(seconds: 0.4)
+        e: sleepFor(seconds: 0.4)
       }
     |}
     it "returns a partial response and error messages" do
       expected_data = {
-        "a"=>0.7,
-        "b"=>0.7,
-        "c"=>0.7,
+        "a"=>0.4,
+        "b"=>0.4,
+        "c"=>0.4,
         "d"=>nil,
         "e"=>nil,
       }
@@ -79,11 +79,11 @@ describe GraphQL::Schema::TimeoutMiddleware do
   describe "timeout in nested fields" do
     let(:query_string) {%|
     {
-      a: nestedSleep(seconds: 1) {
+      a: nestedSleep(seconds: 0.3) {
         seconds
-        b: nestedSleep(seconds: 0.4) {
+        b: nestedSleep(seconds: 0.3) {
           seconds
-          c: nestedSleep(seconds: 0.4) {
+          c: nestedSleep(seconds: 0.3) {
             seconds
             d: nestedSleep(seconds: 0.4) {
               seconds
@@ -96,14 +96,15 @@ describe GraphQL::Schema::TimeoutMiddleware do
       }
     }
     |}
+
     it "returns a partial response and error messages" do
       expected_data = {
         "a" => {
-          "seconds" => 1.0,
+          "seconds" => 0.3,
           "b" => {
-            "seconds" => 0.4,
+            "seconds" => 0.3,
             "c" => {
-              "seconds"=>0.4,
+              "seconds"=>0.3,
               "d" => {
                 "seconds"=>nil,
                 "e"=>nil
@@ -131,17 +132,17 @@ describe GraphQL::Schema::TimeoutMiddleware do
   describe "long-running fields" do
     let(:query_string) {%|
       {
-        a: sleepFor(seconds: 0.7)
-        b: sleepFor(seconds: 0.7)
-        c: sleepFor(seconds: 1.5)
+        a: sleepFor(seconds: 0.2)
+        b: sleepFor(seconds: 0.2)
+        c: sleepFor(seconds: 0.8)
         d: sleepFor(seconds: 0.1)
       }
     |}
     it "doesn't terminate long-running field execution" do
       expected_data = {
-        "a"=>0.7,
-        "b"=>0.7,
-        "c"=>1.5,
+        "a"=>0.2,
+        "b"=>0.2,
+        "c"=>0.8,
         "d"=>nil,
       }
 
@@ -159,17 +160,17 @@ describe GraphQL::Schema::TimeoutMiddleware do
 
   describe "with a custom block" do
     let(:timeout_middleware) {
-      GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2) do |err, query|
+      GraphQL::Schema::TimeoutMiddleware.new(max_seconds: max_seconds) do |err, query|
         raise("Query timed out after 2s: #{query.class.name}")
       end
     }
     let(:query_string) {%|
       {
-        a: sleepFor(seconds: 0.7)
-        b: sleepFor(seconds: 0.7)
-        c: sleepFor(seconds: 0.7)
-        d: sleepFor(seconds: 0.7)
-        e: sleepFor(seconds: 0.7)
+        a: sleepFor(seconds: 0.4)
+        b: sleepFor(seconds: 0.4)
+        c: sleepFor(seconds: 0.4)
+        d: sleepFor(seconds: 0.4)
+        e: sleepFor(seconds: 0.4)
       }
     |}