graphql 0.17.2 → 0.18.0

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

@@ -14,7 +14,7 @@ module GraphQL
       include GraphQL::StaticValidation::Message::MessageHelper
 
       class VariableUsage
-        attr_accessor :ast_node, :used_by, :declared_by
+        attr_accessor :ast_node, :used_by, :declared_by, :path
         def used?
           !!@used_by
         end
@@ -50,7 +50,11 @@ module GraphQL
         context.visitor[GraphQL::Language::Nodes::OperationDefinition] << -> (node, parent) {
           # mark variables as defined:
           var_hash = variable_usages_for_context[node]
-          node.variables.each { |var| var_hash[var.name].declared_by = node }
+          node.variables.each { |var|
+            var_usage = var_hash[var.name]
+            var_usage.declared_by = node
+            var_usage.path = context.path
+          }
         }
         context.visitor[GraphQL::Language::Nodes::OperationDefinition].leave << pop_variable_context_stack
 
@@ -74,6 +78,7 @@ module GraphQL
           usage = declared_variables[node.name]
           usage.used_by = usage_context
           usage.ast_node = node
+          usage.path = context.path
         }
 
 
@@ -104,6 +109,7 @@ module GraphQL
             if child_usage.used?
               parent_usage.ast_node   = child_usage.ast_node
               parent_usage.used_by    = child_usage.used_by
+              parent_usage.path       = child_usage.path
             end
           end
           follow_spreads(def_node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
@@ -113,20 +119,15 @@ module GraphQL
       # Determine all the error messages,
       # Then push messages into the validation context
       def create_errors(node_variables, context)
-        errors = []
         # Declared but not used:
-        errors += node_variables
+        node_variables
           .select { |name, usage| usage.declared? && !usage.used? }
-          .map { |var_name, usage| ["Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by] }
+          .each { |var_name, usage| context.errors << message("Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by, path: usage.path) }
 
         # Used but not declared:
-        errors += node_variables
+        node_variables
           .select { |name, usage| usage.used? && !usage.declared? }
-          .map { |var_name, usage| ["Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node] }
-
-        errors.each do |error_args|
-          context.errors << message(*error_args)
-        end
+          .each { |var_name, usage| context.errors << message("Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node, path: usage.path) }
       end
     end
   end

data/lib/graphql/static_validation/type_stack.rb

@@ -29,6 +29,9 @@ module GraphQL
       # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
       attr_reader :argument_definitions
 
+      # @return [Array<String>] fields which have been entered (by their AST name)
+      attr_reader :path
+
       # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
       # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
       def initialize(schema, visitor)
@@ -37,6 +40,7 @@ module GraphQL
         @field_definitions = []
         @directive_definitions = []
         @argument_definitions = []
+        @path = []
         visitor.enter << -> (node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
         visitor.leave << -> (node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
       end
@@ -63,25 +67,38 @@ module GraphQL
             object_type = object_type.unwrap
           end
           stack.object_types.push(object_type)
+          push_path_member(stack, node)
         end
 
         def pop(stack, node)
           stack.object_types.pop
+          stack.path.pop
         end
       end
 
-      class FragmentDefinitionStrategy < FragmentWithTypeStrategy; end
-      class InlineFragmentStrategy < FragmentWithTypeStrategy; end
+      class FragmentDefinitionStrategy < FragmentWithTypeStrategy
+        def push_path_member(stack, node)
+          stack.path.push("fragment #{node.name}")
+        end
+      end
+
+      class InlineFragmentStrategy < FragmentWithTypeStrategy
+        def push_path_member(stack, node)
+          stack.path.push("...#{node.type ? " on #{node.type}" : ""}")
+        end
+      end
 
       class OperationDefinitionStrategy
         def push(stack, node)
           # eg, QueryType, MutationType
           object_type = stack.schema.root_type_for_operation(node.operation_type)
           stack.object_types.push(object_type)
+          stack.path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
         end
 
         def pop(stack, node)
           stack.object_types.pop
+          stack.path.pop
         end
       end
 
@@ -98,11 +115,13 @@ module GraphQL
           else
             stack.object_types.push(nil)
           end
+          stack.path.push(node.alias || node.name)
         end
 
         def pop(stack, node)
           stack.field_definitions.pop
           stack.object_types.pop
+          stack.path.pop
         end
       end
 
@@ -137,10 +156,22 @@ module GraphQL
             argument_defn = nil
           end
           stack.argument_definitions.push(argument_defn)
+          stack.path.push(node.name)
         end
 
         def pop(stack, node)
           stack.argument_definitions.pop
+          stack.path.pop
+        end
+      end
+
+      class FragmentSpreadStrategy
+        def push(stack, node)
+          stack.path.push("... #{node.name}")
+        end
+
+        def pop(stack, node)
+          stack.path.pop
         end
       end
 

data/lib/graphql/static_validation/validation_context.rb

@@ -52,6 +52,11 @@ module GraphQL
         @type_stack.field_definitions.last
       end
 
+      # @return [Array<String>] Field names to get to the current field
+      def path
+        @type_stack.path.dup
+      end
+
       # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
       def directive_definition
         @type_stack.directive_definitions.last

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.17.2"
+  VERSION = "0.18.0"
 end

data/readme.md

@@ -15,6 +15,7 @@ A Ruby implementation of [GraphQL](http://graphql.org/).
      - [Testing](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/testing.md)
      - [Code Reuse](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/code_reuse.md)
      - [Security](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/security.md)
+     - [Relay](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/relay.md)
 
 
  - [API Documentation](http://www.rubydoc.info/github/rmosolgo/graphql-ruby)
@@ -88,7 +89,7 @@ result_hash = Schema.execute(query_string)
 If you're building a backend for [Relay](http://facebook.github.io/relay/), you'll need:
 
 - A JSON dump of the schema, which you can get by sending [`GraphQL::Introspection::INTROSPECTION_QUERY`](https://github.com/rmosolgo/graphql-ruby/blob/master/lib/graphql/introspection/introspection_query.rb)
-- Relay-specific helpers for GraphQL like Connections, node fields, and global ids. Here's one example of those: [`graphql-relay`](https://github.com/rmosolgo/graphql-relay-ruby)
+- Relay-specific helpers for GraphQL, see [`GraphQL::Relay`](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/relay.md)
 
 ## Goals
 
@@ -109,7 +110,6 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 
 - `graphql-ruby` + Rails demo ([src](https://github.com/rmosolgo/graphql-ruby-demo) / [heroku](http://graphql-ruby-demo.herokuapp.com))
 - [`graphql-batch`](https://github.com/shopify/graphql-batch), a batched 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.
 
 ### Blog Posts
@@ -127,7 +127,19 @@ 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
-- Type check improvements:
+- StaticValidation improvements
+  - Include `path: [...]` in validation errors
   - 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?
+  - Validators are order-dependent, is this a smell?
+  - Tests for interference between validators are poor
+  - Maybe this is a candidate for a rewrite? Can it somehow work more closely with query analysis? Somehow support the `Query#perform_validation` refactor?
+- Add Rails-y argument validations, eg `less_than: 100`, `max_length: 255`, `one_of: [...]`
+  - Must be customizable
+- Refactor `Query#perform_validation`, how can that be organized better?
+- Relay:
+  - `GlobalNodeIdentification.to_global_id` should receive the type name and _object_, not `id`. (Or, maintain the "`type_name, id` in, `type_name, id` out" pattern?)
+  - Reduce duplication in ArrayConnection / RelationConnection
+  - Improve API for creating edges (better RANGE_ADD support)
+  - If the new edge isn't a member of the connection's objects, raise a nice error
+  - Rename `Connection#object` => `Connection#collection` with deprecation

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -26,7 +26,8 @@ describe GraphQL::Analysis do
     let(:type_collector) { TypeCollector.new }
     let(:analyzers) { [type_collector, node_counter] }
     let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+    let(:variables) { {} }
+    let(:query) { GraphQL::Query.new(DummySchema, query_string, variables: variables) }
     let(:query_string) {%|
       {
         cheese(id: 1) {
@@ -38,7 +39,7 @@ describe GraphQL::Analysis do
 
     it "calls the defined analyzers" do
       collected_types, node_counts = reduce_result
-      expected_visited_types = [QueryType, CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
+      expected_visited_types = [DairyAppQueryType, CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
       assert_equal expected_visited_types, collected_types
       expected_node_counts = {
         GraphQL::Language::Nodes::OperationDefinition => 1,
@@ -46,5 +47,33 @@ describe GraphQL::Analysis do
       }
       assert_equal expected_node_counts, node_counts
     end
+
+    describe "when a variable is missing" do
+      let(:query_string) {%|
+        query something($cheeseId: Int!){
+          cheese(id: $cheeseId) {
+            id
+            flavor
+          }
+        }
+      |}
+      let(:variable_accessor) { -> (memo, visit_type, irep_node) { query.variables["cheeseId"] } }
+
+      before do
+        @previous_query_analyzers = DummySchema.query_analyzers.dup
+        DummySchema.query_analyzers.clear
+        DummySchema.query_analyzers << variable_accessor
+      end
+
+      after do
+        DummySchema.query_analyzers.clear
+        DummySchema.query_analyzers.push(*@previous_query_analyzers)
+      end
+
+      it "returns an error" do
+        error = query.result["errors"].first
+        assert_equal "Variable cheeseId of type Int! was provided invalid value", error["message"]
+      end
+    end
   end
 end

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -187,6 +187,30 @@ describe GraphQL::Analysis::QueryComplexity do
     end
   end
 
+  describe "relay types" do
+    let(:query) { GraphQL::Query.new(StarWarsSchema, query_string) }
+    let(:query_string) {%|
+    {
+      rebels {
+        ships {
+          edges {
+            node {
+              id
+            }
+          }
+          pageInfo {
+            hasNextPage
+          }
+        }
+      }
+    }
+    |}
+
+    it "gets the complexity" do
+      reduce_result
+      assert_equal 7, complexities.last
+    end
+  end
 
   describe "custom complexities" do
     let(:query) { GraphQL::Query.new(complexity_schema, query_string) }

data/spec/graphql/argument_spec.rb

@@ -9,7 +9,7 @@ describe GraphQL::Argument do
       end
     end
 
-    err = assert_raises {
+    err = assert_raises(GraphQL::Schema::InvalidTypeError) {
       schema = GraphQL::Schema.new(query: query_type)
       schema.types
     }

data/spec/graphql/define/instance_definable_spec.rb

@@ -52,4 +52,13 @@ describe GraphQL::Define::InstanceDefinable do
       assert_equal Date.new(2000, 6, 1), tomato.end_planting_on
     end
   end
+
+  describe ".define with keywords" do
+    it "applies definitions from keywords" do
+      okra = Garden::Vegetable.define(name: "Okra", plant_between: Date.new(2000, 5, 1)..Date.new(2000, 7, 1))
+      assert_equal "Okra", okra.name
+      assert_equal Date.new(2000, 5, 1), okra.start_planting_on
+      assert_equal Date.new(2000, 7, 1), okra.end_planting_on
+    end
+  end
 end

data/spec/graphql/field_spec.rb

@@ -69,7 +69,7 @@ describe GraphQL::Field do
         name("something")
       end
       assert_equal "something", field.name
-      assert_raises { field.name = "somethingelse" }
+      assert_raises(RuntimeError) { field.name = "somethingelse" }
       assert_equal "something", field.name
     end
 

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -23,15 +23,15 @@ describe GraphQL::InternalRepresentation::Rewrite do
       op_node = rewrite_result["getCheeses"]
 
       assert_equal 2, op_node.children.length
-      assert_equal QueryType, op_node.return_type
+      assert_equal DairyAppQueryType, op_node.return_type
       first_field = op_node.children.values.first
       assert_equal 3, first_field.children.length
-      assert_equal [QueryType], first_field.definitions.keys
+      assert_equal [DairyAppQueryType], 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.definitions.keys
+      assert_equal [DairyAppQueryType], second_field.definitions.keys
       assert_equal CheeseType, second_field.return_type
       assert second_field.inspect.is_a?(String)
     end

data/spec/graphql/language/generation_spec.rb

@@ -3,20 +3,21 @@ require "spec_helper"
 describe GraphQL::Language::Generation do
   let(:document) { GraphQL::Language::Parser.parse(query_string) }
   let(:query_string) {%|
-    query getStuff($someVar: Int = 1, $anotherVar: [String!]) @skip(if: false) {
+    query getStuff($someVar: Int = 1, $anotherVar: [String!], $skipNested: Boolean! = false) @skip(if: false) {
       myField: someField(someArg: $someVar, ok: 1.4) @skip(if: $anotherVar) @thing(or: "Whatever")
       anotherField(someArg: [1, 2, 3]) {
         nestedField
-        ... moreNestedFields @skip(if: true)
+        ... moreNestedFields @skip(if: $skipNested)
       }
       ... on OtherType @include(unless: false) {
-        field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
+        field(arg: [{ key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER }])
         anotherField
       }
       ... {
         id
       }
     }
+
     fragment moreNestedFields on NestedType @or(something: "ok") {
       anotherNestedField
     }
@@ -30,13 +31,33 @@ describe GraphQL::Language::Generation do
     describe "inputs" do
       let(:query_string) {%|
         query {
-          field(int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: {a: [1, 2, 3], b: {c: "4"}}, unicode_bom: "\xef\xbb\xbfquery")
+          field(int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: { a: [1, 2, 3], b: { c: "4" } }, unicode_bom: "\xef\xbb\xbfquery")
+        }
+      |}
+
+      it "generate" do
+        assert_equal query_string.gsub(/^        /, "").strip, document.to_query_string
+      end
+    end
+
+    describe "schema" do
+      let(:query_string) {%|
+        schema {
+          query: Query
+        }
+
+        type Query {
+          field: String!
         }
       |}
 
       it "generate" do
         assert_equal query_string.gsub(/^        /, "").strip, document.to_query_string
       end
+
+      it "doesn't mutate the document" do
+        assert_equal document.to_query_string, document.to_query_string
+      end
     end
   end
 end

data/spec/graphql/language/parser_spec.rb

@@ -263,6 +263,121 @@ describe GraphQL::Language::Parser do
         assert(document)
       end
     end
+
+    describe "schema" do
+      it "parses the test schema" do
+        schema = DummySchema
+        schema_string = GraphQL::Schema::Printer.print_schema(schema)
+        document = GraphQL::Language::Parser.parse(schema_string)
+
+        assert_equal schema_string, document.to_query_string
+      end
+
+      it "parses mimal schema definition" do
+        document = GraphQL::Language::Parser.parse('schema { query: QueryRoot }')
+
+        schema = document.definitions.first
+        assert_equal 'QueryRoot', schema.query
+        assert_equal nil, schema.mutation
+        assert_equal nil, schema.subscription
+      end
+
+      it "parses full schema definitions" do
+        document = GraphQL::Language::Parser.parse('
+          schema {
+            query: QueryRoot
+            mutation: MutationRoot
+            subscription: SubscriptionRoot
+          }
+        ')
+
+        schema = document.definitions.first
+        assert_equal 'QueryRoot', schema.query
+        assert_equal 'MutationRoot', schema.mutation
+        assert_equal 'SubscriptionRoot', schema.subscription
+      end
+
+      it "parses object types" do
+        document = GraphQL::Language::Parser.parse('
+          type Comment implements Node {
+            id: ID!
+          }
+        ')
+
+        type = document.definitions.first
+        assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, type.class
+        assert_equal 'Comment', type.name
+        assert_equal ['Node'], type.interfaces
+        assert_equal ['id'], type.fields.map(&:name)
+        assert_equal [], type.fields[0].arguments
+        assert_equal 'ID', type.fields[0].type.of_type.name
+      end
+
+      it "parses field arguments" do
+        document = GraphQL::Language::Parser.parse('
+          type Mutation {
+            post(id: ID!, data: PostData = { message: "First!1!", type: BLOG, tags: ["Test", "Annoying"] }): Post
+          }
+        ')
+
+        field = document.definitions.first.fields.first
+        assert_equal ['id', 'data'], field.arguments.map(&:name)
+        data_arg = field.arguments[1]
+        assert_equal 'PostData', data_arg.type.name
+        assert_equal ['message', 'type', 'tags'], data_arg.default_value.arguments.map(&:name)
+        tags_arg = data_arg.default_value.arguments[2]
+        assert_equal ['Test', 'Annoying'], tags_arg.value
+      end
+
+      it "parses scalar types" do
+        document = GraphQL::Language::Parser.parse('scalar DateTime')
+
+        type = document.definitions.first
+        assert_equal GraphQL::Language::Nodes::ScalarTypeDefinition, type.class
+        assert_equal 'DateTime', type.name
+      end
+
+      it "parses interface types" do
+        document = GraphQL::Language::Parser.parse('
+          interface Node {
+            id: ID!
+          }
+        ')
+
+        type = document.definitions.first
+        assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, type.class
+        assert_equal 'Node', type.name
+        assert_equal ['id'], type.fields.map(&:name)
+        assert_equal [], type.fields[0].arguments
+        assert_equal 'ID', type.fields[0].type.of_type.name
+      end
+
+      it "parses enum types" do
+        document = GraphQL::Language::Parser.parse('
+          enum DogCommand { SIT, DOWN, HEEL }
+        ')
+
+        type = document.definitions.first
+        assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, type.class
+        assert_equal 'DogCommand', type.name
+        assert_equal ['SIT', 'DOWN', 'HEEL'], type.values
+      end
+
+      it "parses input object types" do
+        document = GraphQL::Language::Parser.parse('
+          input EmptyMutationInput {
+            clientMutationId: String
+          }
+        ')
+
+        type = document.definitions.first
+        assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, type.class
+        assert_equal 'EmptyMutationInput', type.name
+        assert_equal ['clientMutationId'], type.fields.map(&:name)
+        assert_equal 'String', type.fields[0].type.name
+        assert_equal nil, type.fields[0].default_value
+      end
+    end
   end
 
   describe "errors" do
@@ -286,7 +401,7 @@ describe GraphQL::Language::Parser do
     end
 
     it "handles unexpected ends" do
-      err = assert_raises { GraphQL.parse("{ ") }
+      err = assert_raises(GraphQL::ParseError) { GraphQL.parse("{ ") }
       assert_equal "Unexpected end of document", err.message
     end