graphql 0.10.9 → 0.11.0

data/lib/graphql/non_null_type.rb

@@ -21,10 +21,6 @@ class GraphQL::NonNullType < GraphQL::BaseType
     of_type.coerce_input(value)
   end
 
-  def coerce_result(value)
-    of_type.coerce_result(value)
-  end
-
   def kind
     GraphQL::TypeKinds::NON_NULL
   end

data/lib/graphql/query.rb

@@ -44,7 +44,7 @@ class GraphQL::Query
     @operations = {}
     @provided_variables = variables
     @document = GraphQL.parse(query_string)
-    @document.parts.each do |part|
+    @document.definitions.each do |part|
       if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
         @fragments[part.name] = part
       elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
@@ -104,7 +104,6 @@ class GraphQL::Query
 end
 
 require 'graphql/query/arguments'
-require 'graphql/query/base_execution'
 require 'graphql/query/context'
 require 'graphql/query/directive_chain'
 require 'graphql/query/executor'

data/lib/graphql/query/arguments.rb

@@ -7,8 +7,8 @@ module GraphQL
       extend Forwardable
 
       def initialize(values)
-        @hash = values
-        @values = values.inject({}) do |memo, (inner_key, inner_value)|
+        @original_values = values
+        @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
           memo[inner_key.to_s] = wrap_value(inner_value)
           memo
         end
@@ -17,28 +17,60 @@ module GraphQL
       # @param [String, Symbol] name or index of value to access
       # @return [Object] the argument at that key
       def [](key)
-        @values[key.to_s]
+        @argument_values[key.to_s]
       end
 
       # Get the original Ruby hash
       # @return [Hash] the original values hash
       def to_h
-        @hash
+        @unwrapped_values ||= unwrap_value(@original_values)
       end
 
-      def_delegators :@values, :keys, :values, :each
+      def_delegators :string_key_values, :keys, :values, :each
 
       private
 
       def wrap_value(value)
-        if value.is_a?(Array)
+        case value
+        when Array
           value.map { |item| wrap_value(item) }
-        elsif value.is_a?(Hash)
+        when Hash
           self.class.new(value)
         else
           value
         end
       end
+
+      def unwrap_value(value)
+        case value
+        when Array
+          value.map { |item| unwrap_value(item) }
+        when Hash
+          value.inject({}) do |memo, (key, value)|
+            memo[key] = unwrap_value(value)
+            memo
+          end
+        when GraphQL::Query::Arguments
+          value.to_h
+        else
+          value
+        end
+      end
+
+      def string_key_values
+        @string_key_values ||= stringify_keys(to_h)
+      end
+
+      def stringify_keys(value)
+        case value
+        when Hash
+          value.inject({}) { |memo, (k, v)| memo[k.to_s] = stringify_keys(v); memo }
+        when Array
+          value.map { |v| stringify_keys(v) }
+        else
+          value
+        end
+      end
     end
   end
 end

data/lib/graphql/query/literal_input.rb

@@ -48,7 +48,7 @@ module GraphQL
         module InputObjectLiteral
           def self.coerce(value, type, variables)
             hash = {}
-            value.pairs.each do |arg|
+            value.arguments.each do |arg|
               field_type = type.input_fields[arg.name].type
               hash[arg.name] = LiteralInput.coerce(field_type, arg.value, variables)
             end

data/lib/graphql/query/serial_execution.rb

@@ -1,10 +1,39 @@
 module GraphQL
   class Query
-    class SerialExecution < GraphQL::Query::BaseExecution
+    class SerialExecution
+      # This is the only required method for an Execution strategy.
+      # You could create a custom execution strategy and configure your schema to
+      # use that custom strategy instead.
+      #
+      # @param ast_operation [GraphQL::Language::Nodes::OperationDefinition] The operation definition to run
+      # @param root_type [GraphQL::ObjectType] either the query type or the mutation type
+      # @param query_obj [GraphQL::Query] the query object for this execution
+      # @return [Hash] a spec-compliant GraphQL result, as a hash
+      def execute(ast_operation, root_type, query_obj)
+        operation_resolution.new(
+          ast_operation,
+          root_type,
+          ExecutionContext.new(query_obj, self)
+        ).result
+      end
+
+      def field_resolution
+        self.class::FieldResolution
+      end
+
+      def operation_resolution
+        self.class::OperationResolution
+      end
+
+      def selection_resolution
+        self.class::SelectionResolution
+      end
     end
   end
 end
 
+require 'graphql/query/serial_execution/execution_context'
+require 'graphql/query/serial_execution/value_resolution'
 require 'graphql/query/serial_execution/field_resolution'
 require 'graphql/query/serial_execution/operation_resolution'
 require 'graphql/query/serial_execution/selection_resolution'

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

@@ -0,0 +1,30 @@
+module GraphQL
+  class Query
+    class SerialExecution
+      class ExecutionContext
+        attr_reader :query, :strategy
+
+        def initialize(query, strategy)
+          @query = query
+          @strategy = strategy
+        end
+
+        def get_type(type)
+          @query.schema.types[type]
+        end
+
+        def get_fragment(name)
+          @query.fragments[name]
+        end
+
+        def get_field(type, name)
+          @query.schema.get_field(type, name)
+        end
+
+        def add_error(err)
+          @query.context.errors << err
+        end
+      end
+    end
+  end
+end

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

@@ -2,22 +2,30 @@ module GraphQL
   class Query
     class SerialExecution
       class FieldResolution
-        attr_reader :ast_node, :parent_type, :target, :query, :execution_strategy, :field, :arguments
+        attr_reader :ast_node, :parent_type, :target, :execution_context, :field, :arguments
 
-        def initialize(ast_node, parent_type, target, query, execution_strategy)
+        def initialize(ast_node, parent_type, target, execution_context)
           @ast_node = ast_node
           @parent_type = parent_type
           @target = target
-          @query = query
-          @execution_strategy = execution_strategy
-          @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::LiteralInput.from_arguments(ast_node.arguments, field.arguments, query.variables)
+          @execution_context = execution_context
+          @field =  execution_context.get_field(parent_type, ast_node.name)
+          raise("No field found on #{parent_type.name} '#{parent_type}' for '#{ast_node.name}'") unless field
+          @arguments = GraphQL::Query::LiteralInput.from_arguments(
+            ast_node.arguments,
+            field.arguments,
+            execution_context.query.variables
+          )
         end
 
         def result
           result_name = ast_node.alias || ast_node.name
-          result_value = get_finished_value(get_raw_value)
-          { result_name => result_value  }
+          raw_value = begin
+            get_raw_value
+          rescue GraphQL::ExecutionError => err
+            err
+          end
+          { result_name => get_finished_value(raw_value) }
         end
 
         private
@@ -25,18 +33,14 @@ module GraphQL
         # After getting the value from the field's resolve method,
         # continue by "finishing" the value, eg. executing sub-fields or coercing values
         def get_finished_value(raw_value)
-          if raw_value.nil?
-            nil
-          elsif raw_value.is_a?(GraphQL::ExecutionError)
+          if raw_value.is_a?(GraphQL::ExecutionError)
             raw_value.ast_node = ast_node
-            query.context.errors << raw_value
-            nil
-          else
-            resolved_type = field.type.resolve_type(raw_value)
-            strategy_class = GraphQL::Query::BaseExecution::ValueResolution.get_strategy_for_kind(resolved_type.kind)
-            result_strategy = strategy_class.new(raw_value, resolved_type, target, parent_type, ast_node, query, execution_strategy)
-            result_strategy.result
+            execution_context.add_error(raw_value)
           end
+
+          strategy_class = GraphQL::Query::SerialExecution::ValueResolution.get_strategy_for_kind(field.type.kind)
+          result_strategy = strategy_class.new(raw_value, field.type, target, parent_type, ast_node, execution_context)
+          result_strategy.result
         end
 
 
@@ -44,12 +48,14 @@ module GraphQL
         # - Any middleware on this schema
         # - The field's resolve method
         def get_raw_value
-          steps = query.schema.middleware + [get_middleware_proc_from_field_resolve]
+          steps = execution_context.query.schema.middleware + [get_middleware_proc_from_field_resolve]
           chain = GraphQL::Schema::MiddlewareChain.new(
             steps: steps,
-            arguments: [parent_type, target, field, arguments, query.context]
+            arguments: [parent_type, target, field, arguments, execution_context.query.context]
           )
-          chain.call
+          value = chain.call
+          raise value if value.instance_of?(GraphQL::ExecutionError)
+          value
         end
 
 

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

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

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

@@ -2,33 +2,24 @@ module GraphQL
   class Query
     class SerialExecution
       class SelectionResolution
-        attr_reader :target, :type, :selections, :query, :execution_strategy
+        attr_reader :target, :type, :selections, :execution_context
 
-        def initialize(target, type, selections, query, execution_strategy)
+        def initialize(target, type, selections, execution_context)
           @target = target
           @type = type
           @selections = selections
-          @query = query
-          @execution_strategy = execution_strategy
+          @execution_context = execution_context
         end
 
         def result
-          # 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|
-              flattened_selections = flatten_selection(ast_node)
-              flattened_selections.each do |name, selection|
-                merge_into_result(memo, selection)
-              end
-              memo
-            }
+          flatten_and_merge_selections(selections)
             .values
-            .reduce({}){|memo, ast_node|
-              memo.merge(resolve_field(ast_node))
+            .reduce({}) { |result, ast_node|
+              result.merge(resolve_field(ast_node))
             }
+        rescue GraphQL::InvalidNullError => err
+          execution_context.add_error(err) unless err.parent_error?
+          nil
         end
 
         private
@@ -46,67 +37,59 @@ module GraphQL
 
         def flatten_field(ast_node)
           result_name = ast_node.alias || ast_node.name
-          return { result_name => ast_node }
+          { result_name => ast_node }
         end
 
         def flatten_inline_fragment(ast_node)
-          chain = GraphQL::Query::DirectiveChain.new(ast_node, query) {
+          chain = GraphQL::Query::DirectiveChain.new(ast_node, execution_context.query) {
             flatten_fragment(ast_node)
           }
           chain.result
         end
 
         def flatten_fragment_spread(ast_node)
-          ast_fragment_defn = query.fragments[ast_node.name]
-          chain = GraphQL::Query::DirectiveChain.new(ast_node, query) {
+          ast_fragment_defn = execution_context.get_fragment(ast_node.name)
+          chain = GraphQL::Query::DirectiveChain.new(ast_node, execution_context.query) {
             flatten_fragment(ast_fragment_defn)
           }
           chain.result
         end
 
         def flatten_fragment(ast_fragment)
-          if !fragment_type_can_apply?(ast_fragment)
-            return {}
-          end
-
-          flat_result = {}
-          ast_fragment.selections.each do |selection|
-            flat_selection = flatten_selection(selection)
-            flat_selection.each do |name, selection|
-              merge_into_result(flat_result, selection)
-            end
-          end
-          flat_result
+          return {} unless fragment_type_can_apply?(ast_fragment)
+          flatten_and_merge_selections(ast_fragment.selections)
         end
 
         def fragment_type_can_apply?(ast_fragment)
-          child_type = query.schema.types[ast_fragment.type]
+          child_type = execution_context.get_type(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.kind.fields?
-            # 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
+          field_type = execution_context.get_field(type, field2.name).type.unwrap
+          return field2 unless field_type.kind.fields?
+
+          # 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
+          )
         end
 
         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 = GraphQL::Query::DirectiveChain.new(ast_node, execution_context.query) {
+            execution_context.strategy.field_resolution.new(
+              ast_node,
+              type,
+              target,
+              execution_context
+            ).result
           }
           chain.result
         end
@@ -118,10 +101,20 @@ module GraphQL
             selection.name
           end
 
-          if memo.has_key?(name)
-            memo[name] = merge_fields(memo[name], selection)
+          memo[name] = if memo.has_key?(name)
+            merge_fields(memo[name], selection)
           else
-            memo[name] = selection
+            selection
+          end
+        end
+
+        def flatten_and_merge_selections(selections)
+          selections.reduce({}) do |result, ast_node|
+            flattened_selections = flatten_selection(ast_node)
+            flattened_selections.each do |name, selection|
+              merge_into_result(result, selection)
+            end
+            result
           end
         end
       end