graphql 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 443760bcd1ca8e0c763ba9216cfc511c8c3d1185
-  data.tar.gz: df070125ce170c79d75bb7f5abe4c4303aaf6332
+  metadata.gz: 90c4327894852ac5fa30563c6f75585be564033d
+  data.tar.gz: b5ea5c2c7710196f76bb2773f55cda6380075336
 SHA512:
-  metadata.gz: 9bbe4e2c99893d0bbb4d68ede2bff4acb9e3f8f11b9ff339a4e159db0baf4ccea21f3168ca69eb3cfb1737528f7dcf1a389df2f219b397c1a321416c061ab2af
-  data.tar.gz: ed66af0387e274413d89bed95e9b1f4e36c5d90b542505759046f53d8b6a310894a09f0ca4197872eab1b50bda74b01ad1a745a80f149fba042a8628d02ebfad
+  metadata.gz: f939c511550ce296668dd3154863cb5401ef7d8710b5dd6a165387555ebce6f769ea587d1a798b9ce39b8b69f39ca1120adff150579e892c84fed22d0f26e7be
+  data.tar.gz: b12940f1e651fe6de8fa33ac0ee1a68ed8041e4120a5c48b52a53d4e239f5470d547b616639876d8c6f01b194ea7ab59b0796a2dd5d3c1d98bd06ef79b4b77d9

data/lib/graphql.rb

@@ -3,6 +3,16 @@ require "parslet"
 require "singleton"
 
 module GraphQL
+  class ParseError < StandardError
+    attr_reader :line, :col, :query
+    def initialize(message, line, col, query)
+      super(message)
+      @line = line
+      @col = col
+      @query = query
+    end
+  end
+
   # Turn a query string into an AST
   # @param string [String] a GraphQL query string
   # @param as [Symbol] If you want to use this to parse some _piece_ of a document, pass the rule name (from {GraphQL::Parser})
@@ -12,8 +22,8 @@ module GraphQL
     tree = parser.parse(string)
     GraphQL::TRANSFORM.apply(tree)
   rescue Parslet::ParseFailed => error
-    line, col = error.cause.source.line_and_column
-    raise [error.message, line, col, string].join(", ")
+    line, col = error.cause.source.line_and_column(error.cause.pos)
+    raise GraphQL::ParseError.new(error.message, line, col, string)
   end
 end
 

data/lib/graphql/field.rb

@@ -31,6 +31,7 @@ class GraphQL::Field
   DEFAULT_RESOLVE = -> (o, a, c) { GraphQL::Query::DEFAULT_RESOLVE }
   include GraphQL::DefinitionHelpers::DefinedByConfig
   attr_accessor :arguments, :deprecation_reason, :name, :description, :type
+  attr_reader :resolve_proc
   defined_by_config :arguments, :deprecation_reason, :name, :description, :type, :resolve
 
   def initialize

data/lib/graphql/query.rb

@@ -13,7 +13,7 @@ class GraphQL::Query
   # @param debug [Boolean] if true, errors are raised, if false, errors are put in the `errors` key
   # @param validate [Boolean] if true, `query_string` will be validated with {StaticValidation::Validator}
   # @param operation_name [String] if the query string contains many operations, this is the one which should be executed
-  def initialize(schema, query_string, context: nil, variables: {}, debug: true, validate: true, operation_name: nil)
+  def initialize(schema, query_string, context: nil, variables: {}, debug: false, validate: true, operation_name: nil)
     @schema = schema
     @debug = debug
     @context = Context.new(values: context)

data/lib/graphql/query/base_execution.rb

@@ -21,14 +21,6 @@ module GraphQL
         get_class :FieldResolution
       end
 
-      def fragment_spread_resolution
-        get_class :FragmentSpreadResolution
-      end
-
-      def inline_fragment_resolution
-        get_class :InlineFragmentResolution
-      end
-
       def operation_resolution
         get_class :OperationResolution
       end

data/lib/graphql/query/serial_execution.rb

@@ -6,7 +6,5 @@ module GraphQL
 end
 
 require 'graphql/query/serial_execution/field_resolution'
-require 'graphql/query/serial_execution/fragment_spread_resolution'
-require 'graphql/query/serial_execution/inline_fragment_resolution'
 require 'graphql/query/serial_execution/operation_resolution'
 require 'graphql/query/serial_execution/selection_resolution'

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

@@ -4,12 +4,6 @@ module GraphQL
       class SelectionResolution
         attr_reader :target, :type, :selections, :query, :execution_strategy
 
-        RESOLUTION_STRATEGIES = {
-          GraphQL::Language::Nodes::Field =>          :field_resolution,
-          GraphQL::Language::Nodes::FragmentSpread => :fragment_spread_resolution,
-          GraphQL::Language::Nodes::InlineFragment => :inline_fragment_resolution,
-        }
-
         def initialize(target, type, selections, query, execution_strategy)
           @target = target
           @type = type
@@ -19,34 +13,83 @@ module GraphQL
         end
 
         def result
-          selections.reduce({}) do |memo, ast_field|
-            field_value = resolve_field(ast_field)
-            deep_merge memo, field_value
-          end
+          # In a first pass, we flatten the selection by merging in fields from
+          # any fragments - this prevents us from resolving the same fields
+          # more than one time in cases where fragments repeat fields.
+          # Then, In a second pass, we resolve the flattened set of fields
+          selections
+            .reduce({}){|memo, ast_node|
+              flatten_selection(ast_node).each do |name, selection|
+                if memo.has_key? name
+                  memo[name] = merge_fields(memo[name], selection)
+                else
+                  memo[name] = selection
+                end
+              end
+
+              memo
+            }
+            .values
+            .reduce({}){|memo, ast_node|
+              memo.merge(resolve_field(ast_node))
+            }
         end
 
         private
 
-        def deep_merge(h1, h2)
-          h1.merge(h2) do |key, oldval, newval|
-            if oldval.is_a?(Array) && newval.is_a?(Array)
-              oldval.each_index.map do |i|
-                deep_merge oldval[i], newval[i]
-              end
-            elsif oldval.is_a?(Hash) && newval.is_a?(Hash)
-              deep_merge(oldval, newval)
-            else
-              newval
+        def flatten_selection(ast_node)
+          return {(ast_node.alias || ast_node.name) => ast_node} if ast_node.is_a?(GraphQL::Language::Nodes::Field)
+
+          ast_fragment = get_fragment(ast_node)
+          return {} unless fragment_type_can_apply?(ast_fragment)
+
+          chain = GraphQL::Query::DirectiveChain.new(ast_node, query) {
+            ast_fragment.selections.reduce({}) do |memo, selection|
+              memo.merge(flatten_selection(selection))
             end
+          }
+
+          chain.result || {}
+        end
+
+        def get_fragment(ast_node)
+          if ast_node.is_a? GraphQL::Language::Nodes::FragmentSpread
+            query.fragments[ast_node.name]
+          elsif ast_node.is_a? GraphQL::Language::Nodes::InlineFragment
+            ast_node
+          else
+            raise 'Unrecognized fragment node'
+          end
+        end
+
+        def fragment_type_can_apply?(ast_fragment)
+          child_type = query.schema.types[ast_fragment.type]
+          resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
+          !resolved_type.nil?
+        end
+
+        def merge_fields(field1, field2)
+          field_type = query.schema.get_field(type, field2.name).type.unwrap
+
+          if field_type.is_a?(GraphQL::ObjectType)
+            # create a new ast field node merging selections from each field.
+            # Because of static validation, we can assume that name, alias,
+            # arguments, and directives are exactly the same for fields 1 and 2.
+            GraphQL::Language::Nodes::Field.new(
+              name: field2.name,
+              alias: field2.alias,
+              arguments: field2.arguments,
+              directives: field2.directives,
+              selections: field1.selections + field2.selections
+            )
+          else
+            field2
           end
         end
 
-        def resolve_field(ast_field)
-          chain = GraphQL::Query::DirectiveChain.new(ast_field, query) {
-            strategy_name = RESOLUTION_STRATEGIES[ast_field.class]
-            strategy_class = execution_strategy.public_send(strategy_name)
-            strategy = strategy_class.new(ast_field, type, target, query, execution_strategy)
-            strategy.result
+        def resolve_field(ast_node)
+          chain = GraphQL::Query::DirectiveChain.new(ast_node, query) {
+            execution_strategy.field_resolution.new(ast_node, type, target, query, execution_strategy).result
           }
           chain.result
         end

data/lib/graphql/schema.rb

@@ -21,11 +21,19 @@ class GraphQL::Schema
   end
 
   # A `{ name => type }` hash of types in this schema
-  # @returns Hash
+  # @return [Hash]
   def types
     @types ||= TypeReducer.find_all([query, mutation, GraphQL::Introspection::SchemaType].compact)
   end
 
+  # Execute a query on itself.
+  # See {Query#initialize} for arguments.
+  # @return [Hash] query result, ready to be serialized as JSON
+  def execute(*args)
+    query = GraphQL::Query.new(self, *args)
+    query.result
+  end
+
   # Resolve field named `field_name` for type `parent_type`.
   # Handles dynamic fields `__typename`, `__type` and `__schema`, too
   def get_field(parent_type, field_name)

data/lib/graphql/schema/type_reducer.rb

@@ -48,6 +48,12 @@ class GraphQL::Schema::TypeReducer
         reduce_type(possible_type, type_hash)
       end
     end
+    if type.kind.input_object?
+      type.input_fields.each do |name, input_field|
+        reduce_type(input_field.type, type_hash)
+      end
+    end
+
     type_hash
   end
 

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

@@ -17,7 +17,9 @@ class GraphQL::StaticValidation::VariableUsagesAreAllowed
         arguments = context.directive_definition.arguments
       end
       var_defn_ast = declared_variables[node.value.name]
-      validate_usage(arguments, node, var_defn_ast, context)
+      # Might be undefined :(
+      # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
+      var_defn_ast && validate_usage(arguments, node, var_defn_ast, context)
     }
   end
 

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

@@ -1,31 +1,130 @@
+# The problem is
+#   - Variable usage must be determined at the OperationDefinition level
+#   - You can't tell how fragments use variables until you visit FragmentDefinitions (which may be at the end of the document)
+#
+#  So, this validator includes some crazy logic to follow fragment spreads recursively, while avoiding infinite loops.
+#
+# `graphql-js` solves this problem by:
+#   - re-visiting the AST for each validator
+#   - allowing validators to say `followSpreads: true`
+#
 class GraphQL::StaticValidation::VariablesAreUsedAndDefined
   include GraphQL::StaticValidation::Message::MessageHelper
 
+  class VariableUsage
+    attr_accessor :ast_node, :used_by, :declared_by
+    def used?
+      !!@used_by
+    end
+
+    def declared?
+      !!@declared_by
+    end
+  end
+
+  def variable_hash
+    Hash.new {|h, k| h[k] = VariableUsage.new }
+  end
+
   def validate(context)
-    # holds { name => used? } pairs
-    declared_variables = {}
+    variable_usages_for_context = Hash.new {|hash, key| hash[key] = variable_hash }
+    spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
+    variable_context_stack = []
+
+    # OperationDefinitions and FragmentDefinitions
+    # both push themselves onto the context stack (and pop themselves off)
+    push_variable_context_stack = -> (node, parent) {
+      # initialize the hash of vars for this context:
+      variable_usages_for_context[node]
+      variable_context_stack.push(node)
+    }
+
+    pop_variable_context_stack = -> (node, parent) {
+      variable_context_stack.pop
+    }
 
+
+    context.visitor[GraphQL::Language::Nodes::OperationDefinition] << push_variable_context_stack
     context.visitor[GraphQL::Language::Nodes::OperationDefinition] << -> (node, parent) {
-      declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = false }
+      # mark variables as defined:
+      var_hash = variable_usages_for_context[node]
+      node.variables.each { |var| var_hash[var.name].declared_by = node }
+    }
+    context.visitor[GraphQL::Language::Nodes::OperationDefinition].leave << pop_variable_context_stack
+
+    context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << push_variable_context_stack
+    context.visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << pop_variable_context_stack
+
+    # For FragmentSpreads:
+    #  - find the context on the stack
+    #  - mark the context as containing this spread
+    context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
+      variable_context = variable_context_stack.last
+      spreads_for_context[variable_context] << node.name
     }
 
+    # For VariableIdentifiers:
+    #  - mark the variable as used
+    #  - assign its AST node
     context.visitor[GraphQL::Language::Nodes::VariableIdentifier] << -> (node, parent) {
-      if declared_variables.key?(node.name)
-        declared_variables[node.name] = true
-      else
-        context.errors << message("Variable $#{node.name} is used but not declared", node)
-        GraphQL::Language::Visitor::SKIP
-      end
+      usage_context = variable_context_stack.last
+      declared_variables = variable_usages_for_context[usage_context]
+      usage = declared_variables[node.name]
+      usage.used_by = usage_context
+      usage.ast_node = node
     }
 
-    context.visitor[GraphQL::Language::Nodes::OperationDefinition].leave << -> (node, parent) {
-      unused_variables = declared_variables
-        .select { |name, used| !used }
-        .keys
 
-      unused_variables.each do |var_name|
-        context.errors << message("Variable $#{var_name} is declared but not used", node)
+    context.visitor[GraphQL::Language::Nodes::Document].leave << -> (node, parent) {
+      fragment_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+      operation_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
+
+      operation_definitions.each do |node, node_variables|
+        follow_spreads(node, node_variables, spreads_for_context, fragment_definitions, [])
+        create_errors(node_variables, context)
       end
     }
   end
+
+  private
+
+  # Follow spreads in `node`, looking them up from `spreads_for_context` and finding their match in `fragment_definitions`.
+  # Use those fragments to update {VariableUsage}s in `parent_variables`.
+  # Avoid infinite loops by skipping anything in `visited_fragments`.
+  def follow_spreads(node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
+    spreads = spreads_for_context[node] - visited_fragments
+    spreads.each do |spread_name|
+      def_node, variables = fragment_definitions.find { |def_node, vars| def_node.name == spread_name }
+      next if !def_node
+      visited_fragments << spread_name
+      variables.each do |name, child_usage|
+        parent_usage = parent_variables[name]
+        if child_usage.used?
+          parent_usage.ast_node   = child_usage.ast_node
+          parent_usage.used_by    = child_usage.used_by
+        end
+      end
+      follow_spreads(def_node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
+    end
+  end
+
+  # 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
+      .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] }
+
+    # Used but not declared:
+    errors += 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
+  end
+
 end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.9.2"
+  VERSION = "0.9.3"
 end

data/readme.md

@@ -63,8 +63,7 @@ See also:
 Execute GraphQL queries on a given schema, from a query string.
 
 ```ruby
-query = GraphQL::Query.new(Schema, query_string)
-result_hash = query.result
+result_hash = Schema.execute(query_string)
 # {
 #   "data" => {
 #     "post" => {
@@ -80,7 +79,6 @@ See also:
   -  [`queries_controller.rb`](https://github.com/rmosolgo/graphql-ruby-demo/blob/master/app/controllers/queries_controller.rb) for a Rails example
   - Try it on [heroku](http://graphql-ruby-demo.herokuapp.com)
 
-
 #### Use with Relay
 
 If you're building a backend for [Relay](http://facebook.github.io/relay/), you'll need:
@@ -91,9 +89,6 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 
 ## To Do
 
-- Field merging
-  - if you were to request a field, then request it in a fragment, it would get looked up twice
-  - https://github.com/graphql/graphql-js/issues/19#issuecomment-118515077
 - 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
@@ -101,6 +96,7 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - Write Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser) and use that instead of Parslet
   - Add instrumentation
     - Some way to expose what queries are run, what types & fields are accessed, how long things are taking, etc
+    - before-hooks for every field?
 
 
 ## Goals

data/spec/graphql/directive_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::Directive do
-  let(:result) { GraphQL::Query.new(DummySchema, query_string, variables: {"t" => true, "f" => false}).result }
+  let(:result) { DummySchema.execute(query_string, variables: {"t" => true, "f" => false}) }
   describe 'on fields' do
     let(:query_string) { %|query directives($t: Boolean!, $f: Boolean!) {
       cheese(id: 1) {

data/spec/graphql/id_type_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::ID_TYPE do
-  let(:query) { GraphQL::Query.new(DummySchema, query_string)}
-  let(:result) { query.result }
+  let(:result) { DummySchema.execute(query_string)}
 
   describe 'coercion for int inputs' do
     let(:query_string) { %|query getMilk { cow: milk(id: 1) { id } }| }

data/spec/graphql/interface_type_spec.rb

@@ -12,8 +12,7 @@ describe GraphQL::InterfaceType do
   end
 
   describe 'query evaluation' do
-    let(:query) { GraphQL::Query.new(DummySchema, query_string, context: {}, variables: {"cheeseId" => 2})}
-    let(:result) { query.result }
+    let(:result) { DummySchema.execute(query_string, context: {}, variables: {"cheeseId" => 2})}
     let(:query_string) {%|
       query fav {
         favoriteEdible { fatContent }

data/spec/graphql/introspection/directive_type_spec.rb

@@ -8,7 +8,7 @@ describe GraphQL::Introspection::DirectiveType do
       }
     }
   |}
-  let(:result) { GraphQL::Query.new(DummySchema, query_string).result }
+  let(:result) { DummySchema.execute(query_string) }
 
   it 'shows directive info ' do
     expected = { "data" => {

data/spec/graphql/introspection/introspection_query_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "GraphQL::Introspection::INTROSPECTION_QUERY" do
   let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
-  let(:result) { GraphQL::Query.new(DummySchema, query_string).result }
+  let(:result) { DummySchema.execute(query_string) }
 
   it 'runs' do
     assert(result["data"])

data/spec/graphql/introspection/schema_type_spec.rb

@@ -10,7 +10,8 @@ describe GraphQL::Introspection::SchemaType do
       }
     }
   |}
-  let(:result) { GraphQL::Query.new(DummySchema, query_string).result }
+  let(:result) { DummySchema.execute(query_string) }
+
   it 'exposes the schema' do
     expected = { "data" => {
       "__schema" => {

data/spec/graphql/introspection/type_type_spec.rb

@@ -10,7 +10,7 @@ describe GraphQL::Introspection::TypeType do
        animalProduct: __type(name: "AnimalProduct") { name, kind, possibleTypes { name }, fields { name } }
      }
   |}
-  let(:query) { GraphQL::Query.new(DummySchema, query_string, context: {}, variables: {"cheeseId" => 2})}
+  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"}}},
@@ -61,7 +61,7 @@ describe GraphQL::Introspection::TypeType do
         ]
       }
     }}
-    assert_equal(expected, query.result)
+    assert_equal(expected, result)
   end
 
   describe 'deprecated fields' do
@@ -86,7 +86,7 @@ describe GraphQL::Introspection::TypeType do
           "enumValues"=> dairy_animals + [{"name" => "YAK", "isDeprecated" => true}],
         },
       }}
-      assert_equal(expected, query.result)
+      assert_equal(expected, result)
     end
 
     describe 'input objects' do
@@ -108,7 +108,7 @@ describe GraphQL::Introspection::TypeType do
               ]
             }
           }}
-        assert_equal(expected, query.result)
+        assert_equal(expected, result)
       end
     end
   end

data/spec/graphql/query/executor_spec.rb

@@ -3,14 +3,14 @@ require 'spec_helper'
 describe GraphQL::Query::Executor do
   let(:debug) { false }
   let(:operation_name) { nil }
-  let(:query) { GraphQL::Query.new(
-    DummySchema,
+  let(:schema) { DummySchema }
+  let(:variables) { {"cheeseId" => 2} }
+  let(:result) { schema.execute(
     query_string,
-    variables: {"cheeseId" => 2},
+    variables: variables,
     debug: debug,
     operation_name: operation_name,
   )}
-  let(:result) { query.result }
 
   describe "multiple operations" do
     let(:query_string) { %|
@@ -68,6 +68,51 @@ describe GraphQL::Query::Executor do
   end
 
 
+  describe 'fragment resolution' do
+    let(:schema) {
+      # we will raise if the dairy field is resolved more than one time
+      resolved = false
+
+      DummyQueryType = GraphQL::ObjectType.define do
+        name "Query"
+        field :dairy do
+          type DairyType
+          resolve -> (t, a, c) {
+            raise if resolved
+            resolved = true
+            DAIRY
+          }
+        end
+      end
+
+      GraphQL::Schema.new(query: DummyQueryType, mutation: MutationType)
+    }
+    let(:variables) { nil }
+    let(:query_string) { %|
+      query getDairy {
+        dairy {
+          id
+          ... on Dairy {
+            id
+          }
+          ...repetitiveFragment
+        }
+      }
+      fragment repetitiveFragment on Dairy {
+        id
+      }
+    |}
+
+    it 'resolves each field only one time, even when present in multiple fragments' do
+      expected = {"data" => {
+        "dairy" => { "id" => "1" }
+      }}
+      assert_equal(expected, result)
+    end
+
+  end
+
+
   describe 'runtime errors' do
     let(:query_string) {%| query noMilk { error }|}
     describe 'if debug: false' do

data/spec/graphql/query_spec.rb

@@ -82,6 +82,22 @@ describe GraphQL::Query do
     assert_equal(GraphQL::Language::Nodes::FragmentDefinition, query.fragments['cheeseFields'].class)
   end
 
+  it 'correctly identifies parse error location' do
+    # "Correct" is a bit of an overstatement. All Parslet errors get surfaced
+    # at the beginning of the query they were in, since Parslet sees the query
+    # as invalid. It would be great to have more granularity here.
+    e = assert_raises(GraphQL::ParseError) do
+      GraphQL.parse("
+        query getCoupons {
+          allCoupons: {data{id}}
+        }
+      ")
+    end
+    assert_equal('Extra input after last repetition at line 2 char 9.', e.message)
+    assert_equal(2, e.line)
+    assert_equal(9, e.col)
+  end
+
   describe "merging fragments with different keys" do
     let(:query_string) { %|
       query getCheeseFieldsThroughDairy {
@@ -98,7 +114,6 @@ describe GraphQL::Query do
           id
         }
       }
-
       fragment fatContentFragment on Dairy {
         cheese {
           fatContent
@@ -107,7 +122,6 @@ describe GraphQL::Query do
           fatContent
         }
       }
-
     |}
 
     it "should include keys from each fragment" do

data/spec/graphql/schema/type_reducer_spec.rb

@@ -23,6 +23,26 @@ describe GraphQL::Schema::TypeReducer do
     assert_equal(DairyProductInputType, reducer.result["DairyProductInput"])
   end
 
+  it 'finds types from nested InputObjectTypes' do
+    type_child = GraphQL::InputObjectType.define do
+      name "InputTypeChild"
+      input_field :someField, GraphQL::STRING_TYPE
+    end
+
+    type_parent = GraphQL::InputObjectType.define do
+      name "InputTypeParent"
+      input_field :child, type_child
+    end
+
+    reducer = GraphQL::Schema::TypeReducer.new(type_parent, {})
+    expected = {
+      "InputTypeParent" => type_parent,
+      "InputTypeChild" => type_child,
+      "String" => GraphQL::STRING_TYPE
+    }
+    assert_equal(expected, reducer.result)
+  end
+
   describe 'when a type is invalid' do
     let(:invalid_type) {
       GraphQL::ObjectType.define do

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

@@ -2,13 +2,20 @@ require 'spec_helper'
 
 describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
   let(:document) { GraphQL.parse('
-    query getCheese($id: Int, $str: String, $notUsedVar: Float, $bool: Boolean) {
-      cheese(id: $id) {
-        source(str: $str)
+    query getCheese(
+      $usedVar: Int,
+      $usedInnerVar: String,
+      $usedInlineFragmentVar: Boolean,
+      $usedFragmentVar: Int,
+      $notUsedVar: Float,
+    ) {
+      cheese(id: $usedVar) {
+        source(str: $usedInnerVar)
         whatever(undefined: $undefinedVar)
         ... on Cheese {
-          something(bool: $bool)
+          something(bool: $usedInlineFragmentVar)
         }
+        ... outerCheeseFields
       }
     }
 
@@ -17,7 +24,8 @@ describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
     }
 
     fragment innerCheeseFields on Cheese {
-      source(notDefined: $notDefinedVar)
+      source(notDefined: $undefinedFragmentVar)
+      someField(someArg: $usedFragmentVar)
     }
   ')}
 
@@ -27,16 +35,16 @@ describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
   it "finds variables which are used-but-not-defined or defined-but-not-used" do
     expected = [
       {
-        "message"=>"Variable $undefinedVar is used but not declared",
-        "locations"=>[{"line"=>5, "column"=>30}]
+        "message"=>"Variable $notUsedVar is declared by getCheese but not used",
+        "locations"=>[{"line"=>2, "column"=>5}]
       },
       {
-        "message"=>"Variable $notUsedVar is declared but not used",
-        "locations"=>[{"line"=>2, "column"=>5}]
+        "message"=>"Variable $undefinedVar is used by getCheese but not declared",
+        "locations"=>[{"line"=>11, "column"=>30}]
       },
       {
-        "message"=>"Variable $notDefinedVar is used but not declared",
-        "locations"=>[{"line"=>17, "column"=>27}]
+        "message"=>"Variable $undefinedFragmentVar is used by innerCheeseFields but not declared",
+        "locations"=>[{"line"=>24, "column"=>27}]
       },
     ]
     assert_equal(expected, errors)

data/spec/graphql/static_validation/validator_spec.rb

@@ -32,18 +32,22 @@ describe GraphQL::StaticValidation::Validator do
     describe 'fields & arguments' do
       let(:query_string) { %|
         query getCheese($id: Int!) {
-          cheese(id: $id, bogusArg: true) {
+          cheese(id: $undefinedVar, bogusArg: true) {
             source,
             nonsenseField,
             id(nonsenseArg: 1)
             bogusField(bogusArg: true)
           }
+
+          otherCheese: cheese(id: $id) {
+            source,
+          }
         }
       |}
 
       it 'handles args on invalid fields' do
-        # nonsenseField, nonsenseArg, bogusField, bogusArg
-        assert_equal(4, errors.length)
+        # nonsenseField, nonsenseArg, bogusField, bogusArg, undefinedVar
+        assert_equal(5, errors.length)
       end
     end
 

data/spec/support/dairy_data.rb

@@ -10,4 +10,8 @@ MILKS = {
   1 => Milk.new(1, 0.04, 1),
 }
 
-DAIRY = OpenStruct.new(cheese: CHEESES[1], milks: [MILKS[1]])
+DAIRY = OpenStruct.new(
+  id: 1,
+  cheese: CHEESES[1],
+  milks: [MILKS[1]]
+)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-10 00:00:00.000000000 Z
+date: 2015-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -215,8 +215,6 @@ files:
 - lib/graphql/query/executor.rb
 - lib/graphql/query/serial_execution.rb
 - lib/graphql/query/serial_execution/field_resolution.rb
-- lib/graphql/query/serial_execution/fragment_spread_resolution.rb
-- lib/graphql/query/serial_execution/inline_fragment_resolution.rb
 - lib/graphql/query/serial_execution/operation_resolution.rb
 - lib/graphql/query/serial_execution/selection_resolution.rb
 - lib/graphql/query/type_resolver.rb

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

@@ -1,22 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      class FragmentSpreadResolution < GraphQL::Query::BaseExecution::SelectedObjectResolution
-        attr_reader :ast_fragment, :resolved_type
-        def initialize(ast_node, type, target, query, execution_strategy)
-          super
-          @ast_fragment = query.fragments[ast_node.name]
-          child_type = query.schema.types[ast_fragment.type]
-          @resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
-        end
-
-        def result
-          return {} if resolved_type.nil?
-          selections = ast_fragment.selections
-          resolver = execution_strategy.selection_resolution.new(target, resolved_type, selections, query, execution_strategy)
-          resolver.result
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      class InlineFragmentResolution  < GraphQL::Query::BaseExecution::SelectedObjectResolution
-        attr_reader :resolved_type
-        def initialize(ast_node, type, target, query, execution_strategy)
-          super
-          child_type = query.schema.types[ast_node.type]
-          @resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
-        end
-
-        def result
-          return {} if resolved_type.nil?
-          selections = ast_node.selections
-          resolver = execution_strategy.selection_resolution.new(target, resolved_type, selections, query, execution_strategy)
-          resolver.result
-        end
-      end
-    end
-  end
-end