graphql 0.11.0 → 0.11.1

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

@@ -19,7 +19,7 @@ class GraphQL::StaticValidation::FieldsAreDefinedOnType
       return GraphQL::Language::Visitor::SKIP
     end
 
-    field =  parent_type.fields[ast_field.name]
+    field =  parent_type.get_field(ast_field.name)
     if field.nil?
       errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent)
       return GraphQL::Language::Visitor::SKIP

data/lib/graphql/static_validation/validation_context.rb

@@ -0,0 +1,63 @@
+module GraphQL
+  module StaticValidation
+    # The validation context gets passed to each validator.
+    #
+    # It exposes a {GraphQL::Language::Visitor} where validators may add hooks. ({Visitor#visit} is called in {Validator#validate})
+    #
+    # It provides access to the schema & fragments which validators may read from.
+    #
+    # It holds a list of errors which each validator may add to.
+    #
+    # It also provides limited access to the {TypeStack} instance,
+    # which tracks state as you climb in and out of different fields.
+    class ValidationContext
+      attr_reader :schema, :document, :errors, :visitor, :fragments, :operations
+      def initialize(schema, document)
+        @schema = schema
+        @document = document
+        @fragments = {}
+        @operations = {}
+
+        document.definitions.each do |definition|
+          case definition
+          when GraphQL::Language::Nodes::FragmentDefinition
+            @fragments[definition.name] = definition
+          when GraphQL::Language::Nodes::OperationDefinition
+            @operations[definition.name] = definition
+          end
+        end
+
+        @errors = []
+        @visitor = GraphQL::Language::Visitor.new
+        @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
+      end
+
+      def object_types
+        @type_stack.object_types
+      end
+
+      # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
+      def field_definition
+        @type_stack.field_definitions.last
+      end
+
+      # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
+      def directive_definition
+        @type_stack.directive_definitions.last
+      end
+
+      # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
+      def argument_definition
+        # Don't get the _last_ one because that's the current one.
+        # Get the second-to-last one, which is the parent of the current one.
+        @type_stack.argument_definitions[-2]
+      end
+
+      # Don't try to validate dynamic fields
+      # since they aren't defined by the type system
+      def skip_field?(field_name)
+        GraphQL::Schema::DYNAMIC_FIELDS.include?(field_name)
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/validator.rb

@@ -19,62 +19,11 @@ class GraphQL::StaticValidation::Validator
   # @param document [GraphQL::Language::Nodes::Document]
   # @return [Array<Hash>]
   def validate(document)
-    context = Context.new(@schema, document)
+    context = GraphQL::StaticValidation::ValidationContext.new(@schema, document)
     @rules.each do |rules|
       rules.new.validate(context)
     end
     context.visitor.visit(document)
     context.errors.map(&:to_h)
   end
-
-  # The validation context gets passed to each validator.
-  #
-  # It exposes a {GraphQL::Language::Visitor} where validators may add hooks. ({Visitor#visit} is called in {Validator#validate})
-  #
-  # It provides access to the schema & fragments which validators may read from.
-  #
-  # It holds a list of errors which each validator may add to.
-  #
-  # It also provides limited access to the {TypeStack} instance,
-  # which tracks state as you climb in and out of different fields.
-  class Context
-    attr_reader :schema, :document, :errors, :visitor, :fragments
-    def initialize(schema, document)
-      @schema = schema
-      @document = document
-      @fragments = document.definitions.each_with_object({}) do |part, memo|
-        part.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && memo[part.name] = part
-      end
-      @errors = []
-      @visitor = GraphQL::Language::Visitor.new
-      @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
-    end
-
-    def object_types
-      @type_stack.object_types
-    end
-
-    # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
-    def field_definition
-      @type_stack.field_definitions.last
-    end
-
-    # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
-    def directive_definition
-      @type_stack.directive_definitions.last
-    end
-
-    # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
-    def argument_definition
-      # Don't get the _last_ one because that's the current one.
-      # Get the second-to-last one, which is the parent of the current one.
-      @type_stack.argument_definitions[-2]
-    end
-
-    # Don't try to validate dynamic fields
-    # since they aren't defined by the type system
-    def skip_field?(field_name)
-      GraphQL::Schema::DYNAMIC_FIELDS.include?(field_name)
-    end
-  end
 end

data/lib/graphql/version.rb

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

data/readme.md

@@ -58,7 +58,10 @@ QueryType = GraphQL::ObjectType.define do
 end
 
 # Then create your schema
-Schema = GraphQL::Schema.new(query: QueryType)
+Schema = GraphQL::Schema.new(
+  query: QueryType,
+  max_depth: 8,
+)
 ```
 
 See also:
@@ -108,24 +111,6 @@ https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-
 3. http://mgiroux.me/2015/getting-started-with-rails-graphql-relay/
 4. http://mgiroux.me/2015/uploading-files-using-relay-with-rails/
 
-## To Do
-
-- 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)
-  - make `DefinitionHelpers` more friendly for extension
-- Interface's possible types should be a property of the schema, not the interface
-- 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:
-  - 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
-    - For a subscription, `graphql` would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)
-
 ## Goals
 
 - Implement the GraphQL spec & support a Relay front end
@@ -145,8 +130,22 @@ https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-
 - [`graphql-batch`](https://github.com/shopify/graphql-batch), a batched query execution strategy
 - [`graphql-parallel`](https://github.com/rmosolgo/graphql-parallel), an asynchronous query execution strategy
 - [Example Relay support](https://github.com/rmosolgo/graphql-relay-ruby) in Ruby
+- [`graphql-libgraphqlparser`](https://github.com/rmosolgo/graphql-libgraphqlparser), bindings to [libgraphqlparser](https://github.com/graphql/libgraphqlparser), a C-level parser.
 
-## P.S.
+## To Do
 
-- Thanks to @sgwilym for the great logo!
-- Definition API heavily inspired by @seanchas's [implementation of GraphQL](https://github.com/seanchas/graphql)
+- 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)
+  - make `DefinitionHelpers` more friendly for extension
+- Interface's possible types should be a property of the schema, not the interface
+- Type lookup should be by type name (to support reloaded constants in Rails code)
+- Depth validator should be aware of fragments
+- 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)
+- Add docs for shared behaviors & DRY code
+- Optimize the pure-Ruby parser (hand-write, RACC?!)
+- Big ideas:
+  - 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
+    - For a subscription, `graphql` would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)

data/spec/graphql/enum_type_spec.rb

@@ -16,4 +16,12 @@ describe GraphQL::EnumType do
   it 'has value description' do
     assert_equal("Animal with horns", enum.values['GOAT'].description)
   end
+
+  describe 'validate_input with bad input' do
+    let(:result) { DairyAnimalEnum.validate_input('bad enum') }
+
+    it 'returns an invalid result' do
+      assert(!result.valid?)
+    end
+  end
 end

data/spec/graphql/input_object_type_spec.rb

@@ -12,8 +12,106 @@ describe GraphQL::InputObjectType do
 
   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)
+      values_obj = MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})
+      assert DairyProductInputType.valid_input?(values_obj)
+    end
+
+    describe 'validate_input with non-enumerable input' do
+      it "returns a valid result for MinimumInputObject" do
+        result = DairyProductInputType.validate_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}))
+        assert(result.valid?)
+      end
+
+      it "returns an invalid result for MinimumInvalidInputObject" do
+        invalid_input = MinimumInputObject.new({"source" => "KOALA", "fatContent" => 0.4})
+        result = DairyProductInputType.validate_input(invalid_input)
+        assert(!result.valid?)
+      end
+    end
+
+    describe 'validate_input with enumerable input' do
+      describe 'with good input' do
+        let(:input) do
+          {
+            'source' => 'COW',
+            'fatContent' => 0.4
+          }
+        end
+        let(:result) { DairyProductInputType.validate_input(input) }
+
+        it 'returns a valid result' do
+          assert(result.valid?)
+        end
+      end
+
+      describe 'with bad enum and float' do
+        let(:result) { DairyProductInputType.validate_input('source' => 'KOALA', 'fatContent' => 'bad_num') }
+
+        it 'returns an invalid result' do
+          assert(!result.valid?)
+        end
+
+        it 'has problems with correct paths' do
+          paths = result.problems.map { |p| p['path'] }
+          assert(paths.include?(['source']))
+          assert(paths.include?(['fatContent']))
+        end
+
+        it 'has correct problem explanation' do
+          expected = DairyAnimalEnum.validate_input('KOALA').problems[0]['explanation']
+
+          source_problem = result.problems.detect { |p| p['path'] == ['source'] }
+          actual = source_problem['explanation']
+
+          assert_equal(expected, actual)
+        end
+      end
+
+      describe 'with extra argument' do
+        let(:result) { DairyProductInputType.validate_input('source' => 'COW', 'fatContent' => 0.4, 'isDelicious' => false) }
+
+        it 'returns an invalid result' do
+          assert(!result.valid?)
+        end
+
+        it 'has problem with correct path' do
+          paths = result.problems.map { |p| p['path'] }
+          assert_equal(paths, [['isDelicious']])
+        end
+
+        it 'has correct problem explanation' do
+          assert(result.problems[0]['explanation'].include?('Field is not defined'))
+        end
+      end
+
+      describe 'list with one invalid element' do
+        let(:list_type) { GraphQL::ListType.new(of_type: DairyProductInputType) }
+        let(:result) do
+          list_type.validate_input([
+            { 'source' => 'COW', 'fatContent' => 0.4 },
+            { 'source' => 'KOALA', 'fatContent' => 0.4 }
+          ])
+        end
+
+        it 'returns an invalid result' do
+          assert(!result.valid?)
+        end
+
+        it 'has one problem' do
+          assert_equal(result.problems.length, 1)
+        end
+
+        it 'has problem with correct path' do
+          path = result.problems[0]['path']
+          assert_equal(path, [1, 'source'])
+        end
+
+        it 'has problem with correct explanation' do
+          expected = DairyAnimalEnum.validate_input('KOALA').problems[0]['explanation']
+          actual = result.problems[0]['explanation']
+          assert_equal(expected, actual)
+        end
+      end
     end
   end
 
@@ -22,7 +120,7 @@ describe GraphQL::InputObjectType do
     let(:result) { DummySchema.execute(query_string, variables: variables) }
 
     describe "list inputs" do
-      let(:variables) { {"search" => [MinimumInputObject.new]} }
+      let(:variables) { {"search" => [MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})]} }
       let(:query_string) {%|
         query getCheeses($search: [DairyProductInput]!){
             sheep: searchDairy(product: [{source: SHEEP, fatContent: 0.1}]) {

data/spec/graphql/introspection/schema_type_spec.rb

@@ -19,15 +19,15 @@ describe GraphQL::Introspection::SchemaType do
         "queryType"=>{
           "fields"=>[
             {"name"=>"cheese"},
-            {"name"=>"milk"},
-            {"name"=>"dairy"},
-            {"name"=>"fromSource"},
-            {"name"=>"favoriteEdible"},
             {"name"=>"cow"},
-            {"name"=>"searchDairy"},
+            {"name"=>"dairy"},
             {"name"=>"error"},
             {"name"=>"executionError"},
-            {"name"=>"maybeNull"}
+            {"name"=>"favoriteEdible"},
+            {"name"=>"fromSource"},
+            {"name"=>"maybeNull"},
+            {"name"=>"milk"},
+            {"name"=>"searchDairy"},
           ]
         },
         "mutationType"=> {

data/spec/graphql/introspection/type_type_spec.rb

@@ -12,11 +12,11 @@ describe GraphQL::Introspection::TypeType do
   |}
   let(:result) { DummySchema.execute(query_string, context: {}, variables: {"cheeseId" => 2}) }
   let(:cheese_fields) {[
-    {"name"=>"id",          "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "Int"}}},
     {"name"=>"flavor",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
+    {"name"=>"id",          "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "Int"}}},
     {"name"=>"origin",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
-    {"name"=>"source",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "DairyAnimal"}}},
     {"name"=>"similarCheese", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
+    {"name"=>"source",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "DairyAnimal"}}},
   ]}
 
   let(:dairy_animals) {[
@@ -37,11 +37,11 @@ describe GraphQL::Introspection::TypeType do
           {"name"=>"AnimalProduct"}
         ],
         "fields"=>[
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"ID"}}},
-          {"type"=>{"name"=>"DairyAnimal", "ofType"=>nil}},
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"String"}}},
           {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}},
           {"type"=>{"name"=>"List", "ofType"=>{"name"=>"String"}}},
+          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"ID"}}},
+          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"String"}}},
+          {"type"=>{"name"=>"DairyAnimal", "ofType"=>nil}},
         ]
       },
       "dairyAnimal"=>{
@@ -75,7 +75,7 @@ describe GraphQL::Introspection::TypeType do
     |}
     let(:deprecated_fields) { {"name"=>"fatContent", "isDeprecated"=>true, "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}} }
     it 'can expose deprecated fields' do
-      new_cheese_fields = cheese_fields + [deprecated_fields]
+      new_cheese_fields = [deprecated_fields] + cheese_fields
       expected = { "data" => {
         "cheeseType" => {
           "name"=> "Cheese",

data/spec/graphql/language/transform_spec.rb

@@ -113,17 +113,21 @@ describe GraphQL::Language::Transform do
 
   it 'transforms input objects' do
     res_one_pair    = get_result(%q|{one: 1}|, parse: :value_input_object)
-    res_two_pair    = get_result(%q|{first: "Apple", second: "Banana"}|, parse: :value_input_object)
+    res_many_pair   = get_result(%q|{first: "Apple", second: "Banana", third: ORANGE}|, parse: :value_input_object)
     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.arguments[0].name)
     assert_equal(1    , res_one_pair.arguments[0].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("first" , res_many_pair.arguments[0].name)
+    assert_equal("Apple" , res_many_pair.arguments[0].value)
+    assert_equal("second", res_many_pair.arguments[1].name)
+    assert_equal("Banana", res_many_pair.arguments[1].value)
+
+    assert(res_many_pair.arguments[2].value.is_a?(GraphQL::Language::Nodes::Enum))
+    assert_equal("third",  res_many_pair.arguments[2].name)
+    assert_equal("ORANGE", res_many_pair.arguments[2].value.name)
 
     assert_equal([], res_empty.arguments)
     assert_equal([], res_empty_space.arguments)

data/spec/graphql/list_type_spec.rb

@@ -6,4 +6,27 @@ describe GraphQL::ListType do
   it 'coerces elements in the list' do
     assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_input([1, 2, 3]).inspect)
   end
+
+  describe 'validate_input with bad input' do
+    let(:bad_num) { 'bad_num' }
+    let(:result) { float_list.validate_input([bad_num, 2.0, 3.0]) }
+
+    it 'returns an invalid result' do
+      assert(!result.valid?)
+    end
+
+    it 'has one problem' do
+      assert_equal(result.problems.length, 1)
+    end
+
+    it 'has path [0]' do
+      assert_equal(result.problems[0]['path'], [0])
+    end
+
+    it 'has the correct explanation' do
+      expected = GraphQL::FLOAT_TYPE.validate_input(bad_num).problems[0]['explanation']
+      actual = result.problems[0]['explanation']
+      assert_equal(actual, expected)
+    end
+  end
 end