graphql 0.10.9 → 0.11.0

data/lib/graphql/query/{base_execution → serial_execution}/value_resolution.rb

@@ -1,6 +1,6 @@
 module GraphQL
   class Query
-    class BaseExecution
+    class SerialExecution
       module ValueResolution
         def self.get_strategy_for_kind(kind)
           TYPE_KIND_STRATEGIES[kind] || raise("No value resolution strategy for #{kind}!")
@@ -8,29 +8,33 @@ module GraphQL
 
         class BaseResolution
           attr_reader :value, :field_type, :target, :parent_type,
-            :ast_field, :query, :execution_strategy
-          def initialize(value, field_type, target, parent_type, ast_field, query, execution_strategy)
+            :ast_field, :execution_context
+          def initialize(value, field_type, target, parent_type, ast_field, execution_context)
             @value = value
             @field_type = field_type
             @target = target
             @parent_type = parent_type
             @ast_field = ast_field
-            @query = query
-            @execution_strategy = execution_strategy
+            @execution_context = execution_context
           end
 
           def result
+            return nil if value.nil? || value.is_a?(GraphQL::ExecutionError)
+            non_null_result
+          end
+
+          def non_null_result
             raise NotImplementedError, "Should return a value based on initialization params"
           end
 
           def get_strategy_for_kind(*args)
-            GraphQL::Query::BaseExecution::ValueResolution.get_strategy_for_kind(*args)
+            GraphQL::Query::SerialExecution::ValueResolution.get_strategy_for_kind(*args)
           end
         end
 
         class ScalarResolution < BaseResolution
           # Apply the scalar's defined `coerce_result` method to the value
-          def result
+          def non_null_result
             field_type.coerce_result(value)
           end
         end
@@ -38,39 +42,44 @@ module GraphQL
         class ListResolution < BaseResolution
           # For each item in the list,
           # Resolve it with the "wrapped" type of this list
-          def result
+          def non_null_result
             wrapped_type = field_type.of_type
+            strategy_class = get_strategy_for_kind(wrapped_type.kind)
             value.map do |item|
-              resolved_type = wrapped_type.resolve_type(item)
-              strategy_class = get_strategy_for_kind(resolved_type.kind)
-              inner_strategy = strategy_class.new(item, resolved_type, target, parent_type, ast_field, query, execution_strategy)
+              inner_strategy = strategy_class.new(item, wrapped_type, target, parent_type, ast_field, execution_context)
               inner_strategy.result
             end
           end
         end
 
-        class ObjectResolution < BaseResolution
-          # Resolve the selections on this object
-          def result
-            resolver = execution_strategy.selection_resolution.new(value, field_type, ast_field.selections, query, execution_strategy)
-            resolver.result
+        class HasPossibleTypeResolution < BaseResolution
+          def non_null_result
+            resolved_type = field_type.resolve_type(value)
+            strategy_class = get_strategy_for_kind(resolved_type.kind)
+            inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, execution_context)
+            inner_strategy.result
           end
         end
 
-        class EnumResolution < BaseResolution
-          # Get the string name for this enum value
-          def result
-            field_type.coerce_result(value)
+        class ObjectResolution < BaseResolution
+          # Resolve the selections on this object
+          def non_null_result
+            execution_context.strategy.selection_resolution.new(
+              value,
+              field_type,
+              ast_field.selections,
+              execution_context
+            ).result
           end
         end
 
         class NonNullResolution < BaseResolution
           # Get the "wrapped" type and resolve the value according to that type
           def result
+            raise GraphQL::InvalidNullError.new(ast_field.name, value) if value.nil? || value.is_a?(GraphQL::ExecutionError)
             wrapped_type = field_type.of_type
-            resolved_type = wrapped_type.resolve_type(value)
-            strategy_class = get_strategy_for_kind(resolved_type.kind)
-            inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, query, execution_strategy)
+            strategy_class = get_strategy_for_kind(wrapped_type.kind)
+            inner_strategy = strategy_class.new(value, wrapped_type, target, parent_type, ast_field, execution_context)
             inner_strategy.result
           end
         end
@@ -79,8 +88,10 @@ module GraphQL
           GraphQL::TypeKinds::SCALAR =>     ScalarResolution,
           GraphQL::TypeKinds::LIST =>       ListResolution,
           GraphQL::TypeKinds::OBJECT =>     ObjectResolution,
-          GraphQL::TypeKinds::ENUM =>       EnumResolution,
+          GraphQL::TypeKinds::ENUM =>       ScalarResolution,
           GraphQL::TypeKinds::NON_NULL =>   NonNullResolution,
+          GraphQL::TypeKinds::INTERFACE =>  HasPossibleTypeResolution,
+          GraphQL::TypeKinds::UNION =>      HasPossibleTypeResolution,
         }
       end
     end

data/lib/graphql/static_validation/complexity_validator.rb

@@ -0,0 +1,27 @@
+class GraphQL::StaticValidation::ComplexityValidator
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def initialize(max_fields:, list_multiplier:)
+    @max_fields = max_fields
+    @list_multiplier = list_multiplier
+  end
+
+  def validate(context)
+    visitor = context.visitor
+    complexity = 0
+    visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
+      field_type = field_definition.type
+      if field_type.kind.list?
+        complexity += list_multiplier
+      else
+        complexity += 1
+      end
+    }
+
+    visitor[GraphQL::Language::Nodes::Document].exit << -> (node, parent) {
+      if complexity > @max_fields
+        context.errors << message("This query is too complex. Request fewer fields.", node)
+      end
+    }
+  end
+end

data/lib/graphql/static_validation/literal_validator.rb

@@ -29,16 +29,16 @@ class GraphQL::StaticValidation::LiteralValidator
       .values
       .select { |f| f.type.kind.non_null? }
       .map(&:name)
-    present_field_names = ast_node.pairs.map(&:name)
+    present_field_names = ast_node.arguments.map(&:name)
     missing_required_field_names = required_field_names - present_field_names
     missing_required_field_names.none?
   end
 
   def present_input_field_values_are_valid(type, ast_node)
     fields = type.input_fields
-    ast_node.pairs.all? do |value|
-     field_type = fields[value.name].type
-     validate(value.value, field_type)
+    ast_node.arguments.all? do |value|
+      field = fields[value.name]
+      field ? validate(value.value, field.type) : true
     end
   end
 

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

@@ -3,6 +3,7 @@ class GraphQL::StaticValidation::ArgumentLiteralsAreCompatible < GraphQL::Static
     return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
     validator = GraphQL::StaticValidation::LiteralValidator.new
     arg_defn = defn.arguments[node.name]
+    return unless arg_defn
     valid = validator.validate(node.value, arg_defn.type)
     if !valid
       kind_of_node = node_type(parent)

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

@@ -3,7 +3,7 @@ class GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped
 
   def validate(context)
     literal_validator = GraphQL::StaticValidation::LiteralValidator.new
-    context.visitor[GraphQL::Language::Nodes::Variable] << -> (node, parent) {
+    context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
       if !node.default_value.nil?
         validate_default_value(node, literal_validator, context)
       end

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

@@ -2,7 +2,7 @@ class GraphQL::StaticValidation::VariablesAreInputTypes
   include GraphQL::StaticValidation::Message::MessageHelper
 
   def validate(context)
-    context.visitor[GraphQL::Language::Nodes::Variable] << -> (node, parent) {
+    context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
       validate_is_input_type(node, context)
     }
   end

data/lib/graphql/static_validation/validator.rb

@@ -42,7 +42,7 @@ class GraphQL::StaticValidation::Validator
     def initialize(schema, document)
       @schema = schema
       @document = document
-      @fragments = document.parts.each_with_object({}) do |part, memo|
+      @fragments = document.definitions.each_with_object({}) do |part, memo|
         part.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && memo[part.name] = part
       end
       @errors = []

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.10.9"
+  VERSION = "0.11.0"
 end

data/readme.md

@@ -102,6 +102,7 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-react-component-cb3f9ee95eca
 
 #### Tutorials
+
 1. https://medium.com/@khor/relay-facebook-on-rails-8b4af2057152
 2. https://blog.jacobwgillespie.com/from-rest-to-graphql-b4e95e94c26b#.4cjtklrwt
 3. http://mgiroux.me/2015/getting-started-with-rails-graphql-relay/
@@ -111,12 +112,15 @@ https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-
 
 - Code clean-up
   - Raise if you try to configure an attribute which doesn't suit the type (ie, if you try to define `resolve` on an ObjectType, it should somehow raise)
-  - Clean up file structure in `lib/query` (don't need serial_execution namespace anymore)
-- Accept strings for circular type references
+  - make `DefinitionHelpers` more friendly for extension
 - Interface's possible types should be a property of the schema, not the interface
-- Statically validate type of variables (see early return in LiteralValidator)
+- Type lookup should be by type name (to support reloaded constants in Rails code)
+- Add a complexity validator (reject queries if they're too big)
+- Add a custom dump for Relay (it expects default value strings to be double-quoted)
+- Make variable validation provide a specific, useful message
+- Add docs for shared behaviors & DRY code
+- After releasing the next version, use it for [graphql-libgraphqlparser](https://github.com/rmosolgo/graphql-libgraphqlparser-ruby)
 - Big ideas:
-  - Use [graphql-parser](https://github.com/shopify/graphql-parser) (Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser)) instead of Parslet ([underway-ish](https://github.com/rmosolgo/graphql-libgraphqlparser-ruby))
   - Revamp the fixture Schema to be more useful (better names, more extensible)
   - __Subscriptions__
     - This is a good chance to make an `Operation` abstraction of which `query`, `mutation` and `subscription` are members

data/spec/graphql/execution_error_spec.rb

@@ -18,6 +18,7 @@ describe GraphQL::ExecutionError do
         }
         flavor
       }
+      executionError
     }
 
     fragment similarCheeseFields on Cheese {
@@ -36,7 +37,8 @@ describe GraphQL::ExecutionError do
               "flavor" => "Manchego",
             },
             "flavor" => "Brie",
-            }
+            },
+            "executionError" => nil,
           },
           "errors"=>[
             {
@@ -47,6 +49,10 @@ describe GraphQL::ExecutionError do
               "message"=>"No cheeses are made from Yak milk!",
               "locations"=>[{"line"=>8, "column"=>9}]
             },
+            {
+              "message"=>"There was an execution error",
+              "locations"=>[{"line"=>16, "column"=>7}]
+            },
           ]
         }
       assert_equal(expected_result, result)

data/spec/graphql/field_spec.rb

@@ -5,6 +5,59 @@ describe GraphQL::Field do
     field = GraphQL::Field.define do
       type(-> { DairyProductUnion })
     end
+
     assert_equal(DairyProductUnion, field.type)
   end
+
+  it "accepts a string as a type" do
+    field = GraphQL::Field.define do
+      type("DairyProductUnion")
+    end
+
+    assert_equal(DairyProductUnion, field.type)
+  end
+
+
+  describe '.property ' do
+    let(:field) do
+      GraphQL::Field.define do
+        # satisfies 'can define by config' below
+        property :internal_prop
+      end
+    end
+
+    it 'can define by config' do
+      assert_equal(field.property, :internal_prop)
+    end
+
+    it 'has nil property if not defined' do
+      no_prop_field = GraphQL::Field.define { }
+      assert_equal(no_prop_field.property, nil)
+    end
+
+    describe 'default resolver' do
+      def acts_like_default_resolver(field, old_prop, new_prop)
+        object = OpenStruct.new(old_prop => 'old value', new_prop => 'new value')
+
+        old_result = field.resolve(object, nil, nil)
+        field.property = new_prop
+        new_result = field.resolve(object, nil, nil)
+        field.property = nil
+        unset_result = field.resolve(object, nil, nil)
+
+        assert_equal(old_result, 'old value')
+        assert_equal(new_result, 'new value')
+        assert_equal(unset_result, GraphQL::Query::DEFAULT_RESOLVE)
+      end
+
+      it 'responds to changes in property' do
+        acts_like_default_resolver(field, :internal_prop, :new_prop)
+      end
+
+      it 'is reassigned if resolve is set to nil' do
+        field.resolve = nil
+        acts_like_default_resolver(field, :internal_prop, :new_prop)
+      end
+    end
+  end
 end

data/spec/graphql/input_object_type_spec.rb

@@ -10,12 +10,19 @@ describe GraphQL::InputObjectType do
     assert(DairyProductInputType.input_fields["fatContent"])
   end
 
+  describe "input validation" do
+    it "Accepts anything that yields key-value pairs to #all?" do
+      values_obj = MinimumInputObject.new
+      assert DairyProductInputType.valid_non_null_input?(values_obj)
+    end
+  end
+
   describe "when sent into a query" do
     let(:variables) { {} }
     let(:result) { DummySchema.execute(query_string, variables: variables) }
 
     describe "list inputs" do
-      let(:variables) { {"search" => [{"source" => "COW"}]} }
+      let(:variables) { {"search" => [MinimumInputObject.new]} }
       let(:query_string) {%|
         query getCheeses($search: [DairyProductInput]!){
             sheep: searchDairy(product: [{source: SHEEP, fatContent: 0.1}]) {

data/spec/graphql/introspection/schema_type_spec.rb

@@ -26,7 +26,8 @@ describe GraphQL::Introspection::SchemaType do
             {"name"=>"cow"},
             {"name"=>"searchDairy"},
             {"name"=>"error"},
-            {"name"=>"maybeNull"},
+            {"name"=>"executionError"},
+            {"name"=>"maybeNull"}
           ]
         },
         "mutationType"=> {

data/spec/graphql/language/transform_spec.rb

@@ -45,11 +45,11 @@ describe GraphQL::Language::Transform do
       }
     |
     res = get_result(query, debug: false)
-    assert_equal(4, res.parts.length)
+    assert_equal(4, res.definitions.length)
 
     res = get_result("{ me {id, birthdate} } # query shorthand")
-    assert_equal(1, res.parts.length)
-    assert_equal("me", res.parts.first.selections.first.name)
+    assert_equal(1, res.definitions.length)
+    assert_equal("me", res.definitions.first.selections.first.name)
   end
 
   it 'transforms operation definitions' do
@@ -117,16 +117,16 @@ describe GraphQL::Language::Transform do
     res_empty       = get_result(%q|{}|, parse: :value_input_object)
     res_empty_space = get_result(%q|{ }|, parse: :value_input_object)
 
-    assert_equal('one', res_one_pair.pairs[0].name)
-    assert_equal(1    , res_one_pair.pairs[0].value)
+    assert_equal('one', res_one_pair.arguments[0].name)
+    assert_equal(1    , res_one_pair.arguments[0].value)
 
-    assert_equal('first' , res_two_pair.pairs[0].name)
-    assert_equal('Apple' , res_two_pair.pairs[0].value)
-    assert_equal('second', res_two_pair.pairs[1].name)
-    assert_equal('Banana', res_two_pair.pairs[1].value)
+    assert_equal('first' , res_two_pair.arguments[0].name)
+    assert_equal('Apple' , res_two_pair.arguments[0].value)
+    assert_equal('second', res_two_pair.arguments[1].name)
+    assert_equal('Banana', res_two_pair.arguments[1].value)
 
-    assert_equal([], res_empty.pairs)
-    assert_equal([], res_empty_space.pairs)
+    assert_equal([], res_empty.arguments)
+    assert_equal([], res_empty_space.arguments)
   end
 
   it 'transforms directives' do
@@ -141,12 +141,12 @@ describe GraphQL::Language::Transform do
   end
 
   it 'transforms unnamed operations' do
-    assert_equal(1, get_result("query { me }").parts.length)
-    assert_equal(1, get_result("mutation { touch }").parts.length)
+    assert_equal(1, get_result("query { me }").definitions.length)
+    assert_equal(1, get_result("mutation { touch }").definitions.length)
   end
 
   it 'transforms escaped characters' do
     res = get_result("{quoted: \"\\\" \\\\ \\/ \\b \\f \\n \\r \\t\"}", parse: :value_input_object)
-    assert_equal("\" \\ / \b \f \n \r \t", res.pairs[0].value)
+    assert_equal("\" \\ / \b \f \n \r \t", res.arguments[0].value)
   end
 end

data/spec/graphql/object_type_spec.rb

@@ -24,5 +24,12 @@ describe GraphQL::ObjectType do
       assert_equal(GraphQL::TypeKinds::NON_NULL, field.type.kind)
       assert_equal(GraphQL::TypeKinds::SCALAR, field.type.of_type.kind)
     end
+
+    it 'exposes defined field property' do
+      field_without_prop = CheeseType.fields['flavor']
+      field_with_prop = CheeseType.fields['fatContent']
+      assert_equal(field_without_prop.property, nil)
+      assert_equal(field_with_prop.property, :fat_content)
+    end
   end
 end

data/spec/graphql/query/arguments_spec.rb

@@ -1,14 +1,14 @@
 require "spec_helper"
 
 describe GraphQL::Query::Arguments do
-  let(:arguments) { GraphQL::Query::Arguments.new({ a: 1, b: 2 }) }
+  let(:arguments) { GraphQL::Query::Arguments.new({ a: 1, b: 2, c: GraphQL::Query::Arguments.new({ d: 3, e: 4}) }) }
 
   it 'returns keys as strings' do
-    assert_equal(['a', 'b'], arguments.keys)
+    assert_equal(['a', 'b', 'c'], arguments.keys)
   end
 
   it 'delegates values to values hash' do
-    assert_equal([1, 2], arguments.values)
+    assert_equal([1, 2, {'d' => 3, 'e' => 4}], arguments.values)
   end
 
   it 'delegates each to values hash' do
@@ -16,10 +16,10 @@ describe GraphQL::Query::Arguments do
     arguments.each do |key, value|
       pairs << [key, value]
     end
-    assert_equal([['a', 1], ['b', 2]], pairs)
+    assert_equal([['a', 1], ['b', 2], ['c', {'d' => 3, 'e' => 4}]], pairs)
   end
 
   it 'returns original Ruby hash values with to_h' do
-    assert_equal({ a: 1, b: 2 }, arguments.to_h)
+    assert_equal({ a: 1, b: 2, c: { d: 3, e: 4 } }, arguments.to_h)
   end
 end