graphql 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08f966586efa49fab35baf8a07f91bf1a8f1b90d
-  data.tar.gz: 1906d5e21b82db60e65acea99164cf8bb2f8e946
+  metadata.gz: 597ceac7f7f1c006aaaf98ff69fb2320e80c08fb
+  data.tar.gz: 8145bb6df94810a05738c2dbde3753c7c8e8e26d
 SHA512:
-  metadata.gz: c191f4862f354f98264c330040e001d7b5eeea2e5c97008bf13d19b196213d6018e4f9e4f48b0e11cb066b0851857791bc445af114caef4560213dbfe6f71436
-  data.tar.gz: e1ee28e2a7450bd018aa32816f7e8461791c8e236a5afa443955a594430d9ae7a12faa567b4056261d2903936e9404cbd1367bf3a13b5562d7ac3b68e2d95ad0
+  metadata.gz: 1127f6886b67be9890dfef2db3708210a319f292fafb35d49dd4f0092330717c783e886710f7573353b7582e8a3fa743367c70ca69e0740afbc11f5a87b77920
+  data.tar.gz: 2ff711f09df54c8e91c97045c72780d6921fcfefce04ebadeb8368b56452e4300680c64689f48b2acadd38686ec3e9b50c72dde5bfe6e780ff891d687367afe1

data/lib/graphql/query.rb

@@ -3,7 +3,7 @@ class GraphQL::Query
   # The executor will send the field's name to the target object
   # and use the result.
   DEFAULT_RESOLVE = :__default_resolve
-  attr_reader :schema, :document, :context, :fragments, :variables
+  attr_reader :schema, :document, :context, :fragments, :variables, :operations, :debug
 
   # Prepare query `query_string` on `schema`
   # @param schema [GraphQL::Schema]
@@ -13,17 +13,12 @@ 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, params: nil, variables: {}, debug: true, validate: true, operation_name: nil)
+  def initialize(schema, query_string, context: nil, variables: {}, debug: true, validate: true, operation_name: nil)
     @schema = schema
     @debug = debug
     @context = Context.new(context)
 
     @variables = variables
-    if params
-      warn("[GraphQL] params option is deprecated for GraphQL::Query#new, use variables instead")
-      @variables = params
-    end
-
     @validate = validate
     @operation_name = operation_name
     @fragments = {}
@@ -45,39 +40,15 @@ class GraphQL::Query
       return { "errors" => validation_errors }
     end
 
-    @result ||= { "data" => execute }
-
-  rescue OperationNameMissingError => err
-    {"errors" => [{"message" => err.message}]}
-  rescue StandardError => err
-    @debug && raise(err)
-    message = "Something went wrong during query execution: #{err}" # \n  #{err.backtrace.join("\n  ")}"
-    {"errors" => [{"message" => message}]}
+    @result ||= Executor.new(self, @operation_name).result
   end
 
   private
 
-  def execute
-    return {} if @operations.none?
-    operation = find_operation(@operation_name, @operations)
-    resolver = OperationResolver.new(operation, self)
-    resolver.result
-  end
-
   def validation_errors
     @validation_errors ||= @schema.static_validator.validate(@document)
   end
 
-  def find_operation(operation_name, operations)
-    if operations.length == 1
-      operations.values.first
-    elsif !operations.key?(operation_name)
-      raise OperationNameMissingError, operations.keys
-    else
-      operations[operation_name]
-    end
-  end
-
   # Expose some query-specific info to field resolve functions.
   # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
   class Context
@@ -89,20 +60,12 @@ class GraphQL::Query
       @arbitrary_hash[key]
     end
   end
-
-  class OperationNameMissingError < StandardError
-    def initialize(names)
-      msg = "You must provide an operation name from: #{names.join(", ")}"
-      super(msg)
-    end
-  end
 end
 
 require 'graphql/query/arguments'
-require 'graphql/query/field_resolution_strategy'
-require 'graphql/query/fragment_spread_resolution_strategy'
-require 'graphql/query/inline_fragment_resolution_strategy'
-require 'graphql/query/operation_resolver'
-require 'graphql/query/selection_resolver'
+require 'graphql/query/base_execution'
+require 'graphql/query/serial_execution'
+require 'graphql/query/value_resolution'
 require 'graphql/query/type_resolver'
 require 'graphql/query/directive_chain'
+require 'graphql/query/executor'

data/lib/graphql/query/base_execution.rb

@@ -0,0 +1,34 @@
+module GraphQL
+  class Query
+    class BaseExecution
+
+      def field_resolution
+        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
+
+      def selection_resolution
+        get_class :SelectionResolution
+      end
+
+      private
+
+      def get_class(class_name)
+        self.class.const_get(class_name)
+      end
+    end
+  end
+end
+
+require 'graphql/query/base_execution/selected_object_resolution'

data/lib/graphql/query/base_execution/selected_object_resolution.rb

@@ -0,0 +1,16 @@
+module GraphQL
+  class Query
+    class BaseExecution
+      class SelectedObjectResolution
+        attr_reader :ast_node, :parent_type, :target, :query, :execution_strategy
+        def initialize(ast_node, parent_type, target, query, execution_strategy)
+          @ast_node = ast_node
+          @parent_type = parent_type
+          @target = target
+          @query = query
+          @execution_strategy = execution_strategy
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/directive_chain.rb

@@ -1,3 +1,4 @@
+# TODO: directives on fragments: http://facebook.github.io/graphql/#sec-Fragment-Directives
 class GraphQL::Query::DirectiveChain
   DIRECTIVE_ON = {
     GraphQL::Language::Nodes::Field =>          GraphQL::Directive::ON_FIELD,
@@ -12,10 +13,15 @@ class GraphQL::Query::DirectiveChain
   }
 
   attr_reader :result
-  def initialize(ast_node, operation_resolver, &block)
-    directives = operation_resolver.query.schema.directives
+  def initialize(ast_node, query, &block)
+    directives = query.schema.directives
     on_what = DIRECTIVE_ON[ast_node.class]
-    ast_directives = GET_DIRECTIVES[ast_node.class].call(ast_node, operation_resolver.query.fragments)
+    ast_directives = GET_DIRECTIVES[ast_node.class].call(ast_node, query.fragments)
+
+    if contains_skip?(ast_directives)
+      ast_directives = ast_directives.reject { |ast_directive| ast_directive.name == 'include' }
+    end
+
     applicable_directives = ast_directives
       .map { |ast_directive| [ast_directive, directives[ast_directive.name]] }
       .select { |directive_pair| directive_pair.last.on.include?(on_what) }
@@ -24,10 +30,15 @@ class GraphQL::Query::DirectiveChain
       @result = block.call
     else
       applicable_directives.map do |(ast_directive, directive)|
-        args = GraphQL::Query::Arguments.new(ast_directive.arguments, directive.arguments, operation_resolver.variables)
+        args = GraphQL::Query::Arguments.new(ast_directive.arguments, directive.arguments, query.variables)
         @result = directive.resolve(args, block)
       end
       @result ||= {}
     end
   end
+
+  private
+  def contains_skip?(directives)
+    directives.any? { |directive| directive.name == 'skip' }
+  end
 end

data/lib/graphql/query/executor.rb

@@ -0,0 +1,53 @@
+module GraphQL
+  class Query
+    class Executor
+      class OperationNameMissingError < StandardError
+        def initialize(names)
+          msg = "You must provide an operation name from: #{names.join(", ")}"
+          super(msg)
+        end
+      end
+
+      attr_reader :query, :operation_name
+      def initialize(query, operation_name)
+        @query = query
+        @operation_name = operation_name
+      end
+
+      def result
+        {"data" => execute }
+      rescue OperationNameMissingError => err
+        {"errors" => [{"message" => err.message}]}
+      rescue StandardError => err
+        query.debug && raise(err)
+        message = "Something went wrong during query execution: #{err}" # \n  #{err.backtrace.join("\n  ")}"
+        {"errors" => [{"message" => message}]}
+      end
+
+      private
+
+      def execute
+        return {} if query.operations.none?
+        operation = find_operation(operation_name, query.operations)
+        if operation.operation_type == "query"
+          root = query.schema.query
+        elsif operation.operation_type == "mutation"
+          root = query.schema.mutation
+        end
+        execution_strategy = GraphQL::Query::SerialExecution.new
+        resolver = execution_strategy.operation_resolution.new(operation, root, query, execution_strategy)
+        resolver.result
+      end
+
+      def find_operation(operation_name, operations)
+        if operations.length == 1
+          operations.values.first
+        elsif !operations.key?(operation_name)
+          raise OperationNameMissingError, operations.keys
+        else
+          operations[operation_name]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution.rb

@@ -0,0 +1,12 @@
+module GraphQL
+  class Query
+    class SerialExecution < GraphQL::Query::BaseExecution
+    end
+  end
+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/field_resolution.rb

@@ -0,0 +1,42 @@
+module GraphQL
+  class Query
+    class SerialExecution
+      class FieldResolution < GraphQL::Query::BaseExecution::SelectedObjectResolution
+        attr_reader :field, :arguments
+
+        def initialize(ast_node, parent_type, target, query, execution_strategy)
+          super
+          @field = query.schema.get_field(parent_type, ast_node.name) || raise("No field found on #{parent_type.name} '#{parent_type}' for '#{ast_node.name}'")
+          @arguments = GraphQL::Query::Arguments.new(ast_node.arguments, field.arguments, query.variables)
+        end
+
+        def result
+          result_name = ast_node.alias || ast_node.name
+          { result_name => result_value}
+        end
+
+        private
+
+        def result_value
+          value = field.resolve(target, arguments, query.context)
+
+          if value == GraphQL::Query::DEFAULT_RESOLVE
+            begin
+              value = target.public_send(ast_node.name)
+            rescue NoMethodError => err
+              raise("Couldn't resolve field '#{ast_node.name}' to #{target.class} '#{target}' (resulted in #{err})")
+            end
+          end
+
+          return nil if value.nil?
+
+
+          resolved_type = field.type.kind.resolve(field.type, value)
+          strategy_class = GraphQL::Query::ValueResolution.get_strategy_for_kind(resolved_type.kind)
+          result_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_node, query, execution_strategy)
+          result_strategy.result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,21 @@
+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

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

@@ -0,0 +1,22 @@
+module GraphQL
+  class Query
+    class SerialExecution
+      class OperationResolution
+        attr_reader :query, :target, :ast_operation_definition, :execution_strategy
+
+        def initialize(ast_operation_definition, target, query, execution_strategy)
+          @ast_operation_definition = ast_operation_definition
+          @query = query
+          @target = target
+          @execution_strategy = execution_strategy
+        end
+
+        def result
+          selections = ast_operation_definition.selections
+          resolver = execution_strategy.selection_resolution.new(nil, target, selections, query, execution_strategy)
+          resolver.result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module GraphQL
+  class Query
+    class SerialExecution
+      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
+          @selections = selections
+          @query = query
+          @execution_strategy = execution_strategy
+        end
+
+        def result
+          selections.reduce({}) do |memo, ast_field|
+            field_value = resolve_field(ast_field)
+            memo.merge(field_value)
+          end
+        end
+
+        private
+
+        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
+          }
+          chain.result
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/value_resolution.rb

@@ -0,0 +1,76 @@
+module GraphQL
+  class Query
+    module ValueResolution
+      def self.get_strategy_for_kind(kind)
+        TYPE_KIND_STRATEGIES[kind] || raise("No value resolution strategy for #{kind}!")
+      end
+
+      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)
+          @value = value
+          @field_type = field_type
+          @target = target
+          @parent_type = parent_type
+          @ast_field = ast_field
+          @query = query
+          @execution_strategy = execution_strategy
+        end
+
+        def result
+          raise NotImplementedError, "Should return a value based on initialization params"
+        end
+      end
+
+      class ScalarResolution < BaseResolution
+        def result
+          field_type.coerce(value)
+        end
+      end
+
+      class ListResolution < BaseResolution
+        def result
+          wrapped_type = field_type.of_type
+          value.map do |item|
+            resolved_type = wrapped_type.kind.resolve(wrapped_type, item)
+            strategy_class = GraphQL::Query::ValueResolution.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.result
+          end
+        end
+      end
+
+      class ObjectResolution < BaseResolution
+        def result
+          resolver = execution_strategy.selection_resolution.new(value, field_type, ast_field.selections, query, execution_strategy)
+          resolver.result
+        end
+      end
+
+      class EnumResolution < BaseResolution
+        def result
+           value.to_s
+        end
+      end
+
+      class NonNullResolution < BaseResolution
+        def result
+          wrapped_type = field_type.of_type
+          resolved_type = wrapped_type.kind.resolve(wrapped_type, value)
+          strategy_class = GraphQL::Query::ValueResolution.get_strategy_for_kind(resolved_type.kind)
+          inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, query, execution_strategy)
+          inner_strategy.result
+        end
+      end
+
+      TYPE_KIND_STRATEGIES = {
+        GraphQL::TypeKinds::SCALAR =>     ScalarResolution,
+        GraphQL::TypeKinds::LIST =>       ListResolution,
+        GraphQL::TypeKinds::OBJECT =>     ObjectResolution,
+        GraphQL::TypeKinds::ENUM =>       EnumResolution,
+        GraphQL::TypeKinds::NON_NULL =>   NonNullResolution,
+      }
+    end
+  end
+end

data/lib/graphql/schema/type_validator.rb

@@ -45,8 +45,8 @@ class GraphQL::Schema::TypeValidator
 
     if type.kind.union?
       union_types = type.possible_types
-      if union_types.length < 2
-        own_errors << "Union #{type_name} must be defined with 2 or more types, not #{union_types.length}"
+      if union_types.none?
+        own_errors << "Union #{type_name} must be defined with 1 or more types, not 0!"
       end
     end
     errors.push(*own_errors)

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

data/readme.md

@@ -91,28 +91,34 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 
 ## To Do
 
-- To match spec:
-  - Directives:
-    - `@skip` has precedence over `@include`
-    - directives on fragments: http://facebook.github.io/graphql/#sec-Fragment-Directives
-  - Union
-    - only require one type https://github.com/facebook/graphql/commit/972fd5aae01195b018d305c82e43f714f9a41679
 - 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
-  - Accept native Ruby types in definitions, then convert them to GraphQL types
-  - Remove deprecated `params:` keyword
+  - Easier built-in type definition
+    - Make an object that accepts type objects, symbols, or corresponding Ruby classes and convertes them to GraphQL types
+    - Hook up that object to `DefinitionConfig`, so it can map from incoming values to GraphQL types
   - Raise if you try to configure an attribute which doesn't suit the type
-- Cook up some path other than "n+1s everywhere"
-  - See Sangria's `project` approach ([in progress](https://github.com/rmosolgo/graphql-ruby/pull/15))
-  - Try debounced approach?
+    - ie, if you try to define `resolve` on an ObjectType, it should somehow raise
+  - Make better inheritance between types
+    - Implement a BaseType (?) and make all type classes extend that
+    - No more extending ObjectType!
+    - Move `TypeKind#unwrap` to BaseType & update all code
+    - Also move `TypeKind#resolve` ?
+- Big ideas:
+  - Cook up some path other than "n+1s everywhere"
+    - See Sangria's `project` approach ([in progress](https://github.com/rmosolgo/graphql-ruby/pull/15))
+    - Try debounced approach?
+  - 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
+
 
 ## Goals
 
 - Implement the GraphQL spec & support a Relay front end
 - Provide idiomatic, plain-Ruby API with similarities to reference implementation where possible
-- Support `graphql-rails`
+- Support Ruby on Rails and Relay
 
 ## Getting Involved
 

data/spec/graphql/directive_spec.rb

@@ -8,6 +8,8 @@ describe GraphQL::Directive do
         # plain fields:
         skipFlavor: flavor @skip(if: true)
         dontSkipFlavor: flavor @skip(if: false)
+        dontSkipDontIncludeFlavor: flavor @skip(if: false), @include(if: false)
+        skipAndInclude: flavor @skip(if: true), @include(if: true)
         includeFlavor: flavor @include(if: $t)
         dontIncludeFlavor: flavor @include(if: $f)
         # fields in fragments
@@ -25,6 +27,7 @@ describe GraphQL::Directive do
     it 'intercepts fields' do
       expected = { "data" =>{
         "cheese" => {
+          "dontSkipDontIncludeFlavor" => "Brie", #skip has precedence over include
           "dontSkipFlavor" => "Brie",
           "includeFlavor" => "Brie",
           "includeId" => 1,

data/spec/graphql/introspection/schema_type_spec.rb

@@ -23,6 +23,7 @@ describe GraphQL::Introspection::SchemaType do
             {"name"=>"favoriteEdible"},
             {"name"=>"searchDairy"},
             {"name"=>"error"},
+            {"name"=>"maybeNull"},
           ]
         },
         "mutationType"=> {

data/spec/graphql/query/executor_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe GraphQL::Query::Executor do
+  let(:debug) { false }
+  let(:operation_name) { nil }
+  let(:query) { GraphQL::Query.new(
+    DummySchema,
+    query_string,
+    variables: {"cheeseId" => 2},
+    debug: debug,
+    operation_name: operation_name,
+  )}
+  let(:result) { query.result }
+
+  describe "multiple operations" do
+    let(:query_string) { %|
+      query getCheese1 { cheese(id: 1) { flavor } }
+      query getCheese2 { cheese(id: 2) { flavor } }
+    |}
+
+    describe "when an operation is named" do
+      let(:operation_name) { "getCheese2" }
+
+      it "runs the named one" do
+        expected = {
+          "data" => {
+            "cheese" => {
+              "flavor" => "Gouda"
+            }
+          }
+        }
+        assert_equal(expected, result)
+      end
+    end
+
+    describe "when one is NOT named" do
+      it "returns an error" do
+        expected = {
+          "errors" => [
+            {"message" => "You must provide an operation name from: getCheese1, getCheese2"}
+          ]
+        }
+        assert_equal(expected, result)
+      end
+    end
+  end
+
+
+  describe 'execution order' do
+    let(:query_string) {%|
+      mutation setInOrder {
+        first:  pushValue(value: 1)
+        second: pushValue(value: 5)
+        third:  pushValue(value: 2)
+        fourth: replaceValues(input: {values: [6,5,4]})
+      }
+    |}
+
+    it 'executes mutations in order' do
+      expected = {"data"=>{
+          "first"=> [1],
+          "second"=>[1, 5],
+          "third"=> [1, 5, 2],
+          "fourth"=> [6, 5 ,4],
+      }}
+      assert_equal(expected, result)
+    end
+  end
+
+
+  describe 'runtime errors' do
+    let(:query_string) {%| query noMilk { error }|}
+    describe 'if debug: false' do
+      let(:debug) { false }
+      it 'turns into error messages' do
+        expected = {"errors"=>[
+          {"message"=>"Something went wrong during query execution: This error was raised on purpose"}
+        ]}
+        assert_equal(expected, result)
+      end
+    end
+
+    describe 'if debug: true' do
+      let(:debug) { true }
+      it 'raises error' do
+        assert_raises(RuntimeError) { result }
+      end
+    end
+  end
+end

data/spec/graphql/query_spec.rb

@@ -1,45 +1,44 @@
 require 'spec_helper'
 
 describe GraphQL::Query do
-  describe '#execute' do
-    let(:query_string) { %|
-      query getFlavor($cheeseId: Int!) {
-        brie: cheese(id: 1)   { ...cheeseFields, taste: flavor },
-        cheese(id: $cheeseId)  {
-          __typename,
-          id,
-          ...cheeseFields,
-          ... edibleFields,
-          ... on Cheese { cheeseKind: flavor },
-        }
-        fromSource(source: COW) { id }
-        fromSheep: fromSource(source: SHEEP) { id }
-        firstSheep: searchDairy(product: {source: SHEEP}) {
-          __typename,
-          ... dairyFields,
-          ... milkFields
-        }
-        favoriteEdible { __typename, fatContent }
+  let(:query_string) { %|
+    query getFlavor($cheeseId: Int!) {
+      brie: cheese(id: 1)   { ...cheeseFields, taste: flavor },
+      cheese(id: $cheeseId)  {
+        __typename,
+        id,
+        ...cheeseFields,
+        ... edibleFields,
+        ... on Cheese { cheeseKind: flavor },
       }
-      fragment cheeseFields on Cheese { flavor }
-      fragment edibleFields on Edible { fatContent }
-      fragment milkFields on Milk { source }
-      fragment dairyFields on AnimalProduct {
-         ... on Cheese { flavor }
-         ... on Milk   { source }
+      fromSource(source: COW) { id }
+      fromSheep: fromSource(source: SHEEP) { id }
+      firstSheep: searchDairy(product: {source: SHEEP}) {
+        __typename,
+        ... dairyFields,
+        ... milkFields
       }
-    |}
-    let(:debug) { false }
-    let(:operation_name) { nil }
-    let(:query) { GraphQL::Query.new(
-      DummySchema,
-      query_string,
-      variables: {"cheeseId" => 2},
-      debug: debug,
-      operation_name: operation_name,
-    )}
-    let(:result) { query.result }
-
+      favoriteEdible { __typename, fatContent }
+    }
+    fragment cheeseFields on Cheese { flavor }
+    fragment edibleFields on Edible { fatContent }
+    fragment milkFields on Milk { source }
+    fragment dairyFields on AnimalProduct {
+       ... on Cheese { flavor }
+       ... on Milk   { source }
+    }
+  |}
+  let(:debug) { false }
+  let(:operation_name) { nil }
+  let(:query) { GraphQL::Query.new(
+    DummySchema,
+    query_string,
+    variables: {"cheeseId" => 2},
+    debug: debug,
+    operation_name: operation_name,
+  )}
+  let(:result) { query.result }
+  describe '#result' do
     it 'returns fields on objects' do
       expected = {"data"=> {
           "brie" =>   { "flavor" => "Brie", "taste" => "Brie" },
@@ -58,96 +57,44 @@ describe GraphQL::Query do
       assert_equal(expected, result)
     end
 
-    it 'exposes fragments' do
-      assert_equal(GraphQL::Language::Nodes::FragmentDefinition, query.fragments['cheeseFields'].class)
-    end
-
-    describe 'runtime errors' do
-      let(:query_string) {%| query noMilk { error }|}
-      describe 'if debug: false' do
-        let(:debug) { false }
-        it 'turns into error messages' do
-          expected = {"errors"=>[
-            {"message"=>"Something went wrong during query execution: This error was raised on purpose"}
-          ]}
-          assert_equal(expected, result)
-        end
-      end
+    describe "when it hits null objects" do
+      let(:query_string) {%|
+        {
+          maybeNull {
+            cheese {
+              flavor,
+              similarCheeses(source: [SHEEP]) { flavor }
+            }
+          }
+        }
+      |}
 
-      describe 'if debug: true' do
-        let(:debug) { true }
-        it 'raises error' do
-          assert_raises(RuntimeError) { result }
-        end
+      it "skips null objects" do
+        expected = {"data"=> {
+          "maybeNull" => { "cheese" => nil }
+        }}
+        assert_equal(expected, result)
       end
     end
+  end
 
-    describe "malformed queries" do
-      describe "whitespace-only" do
-        let(:query_string) { " " }
-        it "doesn't blow up" do
-          assert_equal({"data"=> {}}, result)
-        end
-      end
-
-      describe "empty string" do
-        let(:query_string) { "" }
-        it "doesn't blow up" do
-          assert_equal({"data"=> {}}, result)
-        end
-      end
-    end
+  it 'exposes fragments' do
+    assert_equal(GraphQL::Language::Nodes::FragmentDefinition, query.fragments['cheeseFields'].class)
+  end
 
-    describe "multiple operations" do
-      let(:query_string) { %|
-        query getCheese1 { cheese(id: 1) { flavor } }
-        query getCheese2 { cheese(id: 2) { flavor } }
-      |}
-      describe "when an operation is named" do
-        let(:operation_name) { "getCheese2" }
-        it "runs the named one" do
-          expected = {
-            "data" => {
-              "cheese" => {
-                "flavor" => "Gouda"
-              }
-            }
-          }
-          assert_equal(expected, result)
-        end
-      end
 
-      describe "when one is NOT named" do
-        it "returns an error" do
-          expected = {
-            "errors" => [
-              {"message" => "You must provide an operation name from: getCheese1, getCheese2"}
-            ]
-          }
-          assert_equal(expected, result)
-        end
+  describe "malformed queries" do
+    describe "whitespace-only" do
+      let(:query_string) { " " }
+      it "doesn't blow up" do
+        assert_equal({"data"=> {}}, result)
       end
     end
 
-
-    describe 'execution order' do
-      let(:query_string) {%|
-        mutation setInOrder {
-          first:  pushValue(value: 1)
-          second: pushValue(value: 5)
-          third:  pushValue(value: 2)
-          fourth: replaceValues(input: {values: [6,5,4]})
-        }
-      |}
-
-      it 'executes mutations in order' do
-        expected = {"data"=>{
-            "first"=> [1],
-            "second"=>[1, 5],
-            "third"=> [1, 5, 2],
-            "fourth"=> [6, 5 ,4],
-        }}
-        assert_equal(expected, result)
+    describe "empty string" do
+      let(:query_string) { "" }
+      it "doesn't blow up" do
+        assert_equal({"data"=> {}}, result)
       end
     end
   end

data/spec/graphql/schema/type_validator_spec.rb

@@ -50,19 +50,32 @@ describe GraphQL::Schema::TypeValidator do
 
   describe "when a Union isnt valid" do
     let(:object) {
+      union_types = types
       GraphQL::UnionType.define do
         name "Something"
         description "some union"
-        possible_types [DairyProductInputType]
+        possible_types union_types
       end
     }
     let(:errors) { e = []; GraphQL::Schema::TypeValidator.new.validate(object, e); e;}
-    it 'must be 2+ types, must be only object types' do
-      expected = [
-        "Something.possible_types must be objects, but some aren't: DairyProductInput",
-        "Union Something must be defined with 2 or more types, not 1",
-      ]
-      assert_equal(expected, errors)
+
+    describe 'when non-object types' do
+      let(:types) { [DairyProductInputType] }
+      it 'must be must be only object types' do
+        expected = [
+          "Something.possible_types must be objects, but some aren't: DairyProductInput"
+        ]
+        assert_equal(expected, errors)
+      end
+    end
+    describe 'when no types' do
+      let(:types) { [] }
+      it 'must have a type' do
+        expected = [
+          "Union Something must be defined with 1 or more types, not 0!"
+        ]
+        assert_equal(expected, errors)
+      end
     end
   end
 end

data/spec/support/dairy_app.rb

@@ -62,6 +62,12 @@ MilkType = GraphQL::ObjectType.define do
   end
 end
 
+MaybeNullType = GraphQL::ObjectType.define do
+  name "MaybeNull"
+  description "An object whose fields return nil"
+  field :cheese, CheeseType
+end
+
 DairyProductUnion = GraphQL::UnionType.define do
   name "DairyProduct"
   description "Kinds of food made from milk"
@@ -131,6 +137,11 @@ QueryType = GraphQL::ObjectType.define do
     type GraphQL::STRING_TYPE
     resolve -> (t, a, c) { raise("This error was raised on purpose") }
   end
+
+  # To test possibly-null fields
+  field :maybeNull, MaybeNullType do
+    resolve -> (t, a, c) { OpenStruct.new(cheese: nil) }
+  end
 end
 
 GLOBAL_VALUES = []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-20 00:00:00.000000000 Z
+date: 2015-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -206,13 +206,18 @@ files:
 - lib/graphql/object_type.rb
 - lib/graphql/query.rb
 - lib/graphql/query/arguments.rb
+- lib/graphql/query/base_execution.rb
+- lib/graphql/query/base_execution/selected_object_resolution.rb
 - lib/graphql/query/directive_chain.rb
-- lib/graphql/query/field_resolution_strategy.rb
-- lib/graphql/query/fragment_spread_resolution_strategy.rb
-- lib/graphql/query/inline_fragment_resolution_strategy.rb
-- lib/graphql/query/operation_resolver.rb
-- lib/graphql/query/selection_resolver.rb
+- 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
+- lib/graphql/query/value_resolution.rb
 - lib/graphql/repl.rb
 - lib/graphql/scalar_type.rb
 - lib/graphql/schema.rb
@@ -263,7 +268,7 @@ files:
 - spec/graphql/language/transform_spec.rb
 - spec/graphql/language/visitor_spec.rb
 - spec/graphql/object_type_spec.rb
-- spec/graphql/query/operation_resolver_spec.rb
+- spec/graphql/query/executor_spec.rb
 - spec/graphql/query_spec.rb
 - spec/graphql/schema/field_validator_spec.rb
 - spec/graphql/schema/type_reducer_spec.rb
@@ -312,7 +317,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A GraphQL implementation for Ruby
@@ -331,7 +336,7 @@ test_files:
 - spec/graphql/language/transform_spec.rb
 - spec/graphql/language/visitor_spec.rb
 - spec/graphql/object_type_spec.rb
-- spec/graphql/query/operation_resolver_spec.rb
+- spec/graphql/query/executor_spec.rb
 - spec/graphql/query_spec.rb
 - spec/graphql/schema/field_validator_spec.rb
 - spec/graphql/schema/type_reducer_spec.rb

data/lib/graphql/query/field_resolution_strategy.rb

@@ -1,87 +0,0 @@
-class GraphQL::Query::FieldResolutionStrategy
-  attr_reader :result, :result_value
-
-  def initialize(ast_field, parent_type, target, operation_resolver)
-    field_name = ast_field.name
-    field = operation_resolver.query.schema.get_field(parent_type, field_name) || raise("No field found on #{parent_type.name} '#{parent_type}' for '#{field_name}'")
-    arguments = GraphQL::Query::Arguments.new(ast_field.arguments, field.arguments, operation_resolver.variables)
-    value = field.resolve(target, arguments, operation_resolver.context)
-    if value.nil?
-      @result_value = value
-    else
-      if value == GraphQL::Query::DEFAULT_RESOLVE
-        begin
-          value = target.send(field_name)
-        rescue NoMethodError => err
-          raise("Couldn't resolve field '#{field_name}' to #{target.class} '#{target}' (resulted in #{err})")
-        end
-      end
-      resolved_type = field.type.kind.resolve(field.type, value)
-      strategy_class = self.class.get_strategy_for_kind(resolved_type.kind)
-      result_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, operation_resolver)
-      @result_value = result_strategy.result
-    end
-    result_name = ast_field.alias || ast_field.name
-    @result = { result_name => @result_value}
-  end
-
-  def self.get_strategy_for_kind(kind)
-    FIELD_TYPE_KIND_STRATEGIES[kind] || raise("No strategy for #{kind}")
-  end
-
-  class ScalarResolutionStrategy
-    attr_reader :result
-    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
-      @result = field_type.coerce(value)
-    end
-  end
-
-  class ListResolutionStrategy
-    attr_reader :result
-    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
-      wrapped_type = field_type.of_type
-      @result = value.map do |item|
-        resolved_type = wrapped_type.kind.resolve(wrapped_type, item)
-        strategy_class = GraphQL::Query::FieldResolutionStrategy.get_strategy_for_kind(resolved_type.kind)
-        inner_strategy = strategy_class.new(item, resolved_type, target, parent_type, ast_field, operation_resolver)
-        inner_strategy.result
-      end
-    end
-  end
-
-  class ObjectResolutionStrategy
-    attr_reader :result
-    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
-      resolver = GraphQL::Query::SelectionResolver.new(value, field_type, ast_field.selections, operation_resolver)
-      @result = resolver.result
-    end
-  end
-
-  class EnumResolutionStrategy
-    attr_reader :result
-    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
-      @result = value.to_s
-    end
-  end
-
-  class NonNullResolutionStrategy
-    attr_reader :result
-    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
-      wrapped_type = field_type.of_type
-      resolved_type = wrapped_type.kind.resolve(wrapped_type, value)
-      strategy_class = GraphQL::Query::FieldResolutionStrategy.get_strategy_for_kind(resolved_type.kind)
-      inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, operation_resolver)
-      @result = inner_strategy.result
-    end
-  end
-
-  private
-
-  FIELD_TYPE_KIND_STRATEGIES = {
-    GraphQL::TypeKinds::SCALAR =>     ScalarResolutionStrategy,
-    GraphQL::TypeKinds::LIST =>       ListResolutionStrategy,
-    GraphQL::TypeKinds::OBJECT =>     ObjectResolutionStrategy,
-    GraphQL::TypeKinds::ENUM =>       EnumResolutionStrategy,
-    GraphQL::TypeKinds::NON_NULL =>   NonNullResolutionStrategy,
-  }
-end

data/lib/graphql/query/fragment_spread_resolution_strategy.rb

@@ -1,16 +0,0 @@
-class GraphQL::Query::FragmentSpreadResolutionStrategy
-  attr_reader :result
-  def initialize(ast_fragment_spread, type, target, operation_resolver)
-    fragments = operation_resolver.query.fragments
-    fragment_def = fragments[ast_fragment_spread.name]
-    child_type = operation_resolver.query.schema.types[fragment_def.type]
-    resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
-    if resolved_type.nil?
-      @result = {}
-    else
-      selections = fragment_def.selections
-      resolver = GraphQL::Query::SelectionResolver.new(target, resolved_type, selections, operation_resolver)
-      @result = resolver.result
-    end
-  end
-end

data/lib/graphql/query/inline_fragment_resolution_strategy.rb

@@ -1,14 +0,0 @@
-class GraphQL::Query::InlineFragmentResolutionStrategy
-  attr_reader :result
-  def initialize(ast_inline_fragment, type, target, operation_resolver)
-    child_type = operation_resolver.query.schema.types[ast_inline_fragment.type]
-    resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
-    if resolved_type.nil?
-      @result = {}
-    else
-      selections = ast_inline_fragment.selections
-      resolver = GraphQL::Query::SelectionResolver.new(target, resolved_type, selections, operation_resolver)
-      @result = resolver.result
-    end
-  end
-end

data/lib/graphql/query/operation_resolver.rb

@@ -1,26 +0,0 @@
-class GraphQL::Query::OperationResolver
-  attr_reader :variables, :query, :context
-
-  def initialize(operation_definition, query)
-    @operation_definition = operation_definition
-    @variables = query.variables
-    @query = query
-    @context = query.context
-  end
-
-  def result
-    @result ||= execute(@operation_definition, query)
-  end
-
-  private
-
-  def execute(op_def, query)
-    root = if op_def.operation_type == "query"
-      query.schema.query
-    elsif op_def.operation_type == "mutation"
-      query.schema.mutation
-    end
-    resolver = GraphQL::Query::SelectionResolver.new(nil, root, op_def.selections, self)
-    resolver.result
-  end
-end

data/lib/graphql/query/selection_resolver.rb

@@ -1,20 +0,0 @@
-class GraphQL::Query::SelectionResolver
-  attr_reader :result
-
-  RESOLUTION_STRATEGIES = {
-    GraphQL::Language::Nodes::Field =>          GraphQL::Query::FieldResolutionStrategy,
-    GraphQL::Language::Nodes::FragmentSpread => GraphQL::Query::FragmentSpreadResolutionStrategy,
-    GraphQL::Language::Nodes::InlineFragment => GraphQL::Query::InlineFragmentResolutionStrategy,
-  }
-
-  def initialize(target, type, selections, operation_resolver)
-    @result = selections.reduce({}) do |memo, ast_field|
-      chain = GraphQL::Query::DirectiveChain.new(ast_field, operation_resolver) {
-        strategy_class = RESOLUTION_STRATEGIES[ast_field.class]
-        strategy = strategy_class.new(ast_field, type, target, operation_resolver)
-        strategy.result
-      }
-      memo.merge(chain.result)
-    end
-  end
-end

data/spec/graphql/query/operation_resolver_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Query::OperationResolver do
-  let(:operation) { GraphQL.parse("query getCheese($cheeseId: Int!) { cheese(id: $cheeseId) { name }}", as: :operation_definition) }
-  let(:variables) { {"cheeseId" => 1}}
-  let(:query) { OpenStruct.new(variables: variables, context: nil) }
-  let(:resolver) { GraphQL::Query::OperationResolver.new(operation, query)}
-
-  describe "variables" do
-    it 'returns variables by name' do
-      assert_equal(1, resolver.variables["cheeseId"])
-    end
-  end
-end