graphql 1.1.0 → 1.2.0

data/lib/graphql/language/parser.y

@@ -172,11 +172,13 @@ rule
     | STRING      { return val[0].to_s }
     | TRUE        { return true }
     | FALSE       { return false }
+    | null_value
     | variable
     | list_value
     | object_value
     | enum_value
 
+  null_value: NULL { return make_node(:NullValue, name: val[0], position_source: val[0]) }
   variable: VAR_SIGN name { return make_node(:VariableIdentifier, name: val[1], position_source: val[0]) }
 
   list_value:

data/lib/graphql/object_type.rb

@@ -23,7 +23,8 @@ module GraphQL
   class ObjectType < GraphQL::BaseType
     accepts_definitions :interfaces, :fields, :mutation, field: GraphQL::Define::AssignObjectField
 
-    lazy_defined_attr_accessor :fields, :mutation
+    attr_accessor :fields, :mutation
+    ensure_defined(:fields, :mutation, :interfaces)
 
     # @!attribute fields
     #   @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
@@ -45,7 +46,6 @@ module GraphQL
 
     def interfaces
       @clean_interfaces ||= begin
-        ensure_defined
         if @dirty_interfaces.respond_to?(:map)
           @dirty_interfaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
         else

data/lib/graphql/query.rb

@@ -167,6 +167,27 @@ module GraphQL
       @valid
     end
 
+    def selections(nodes, type)
+      @selections ||= Hash.new { |h, k| h[k] = GraphQL::InternalRepresentation::Selections.build(self, k) }
+      @selections[nodes][type]
+    end
+
+    def get_type(type_name)
+      @warden.get_type(type_name)
+    end
+
+    def get_field(type, name)
+      @warden.get_field(type, name)
+    end
+
+    def possible_types(type)
+      @warden.possible_types(type)
+    end
+
+    def resolve_type(type)
+      @schema.resolve_type(type, @context)
+    end
+
     private
 
     # Assert that the passed-in query string is internally consistent

data/lib/graphql/query/context.rb

@@ -3,16 +3,23 @@ module GraphQL
     # Expose some query-specific info to field resolve functions.
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
-      attr_accessor :execution_strategy
+      attr_reader :execution_strategy
 
-      # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
-      def ast_node
-        irep_node.ast_node
+      def execution_strategy=(new_strategy)
+        # GraphQL::Batch re-assigns this value but it was previously not used
+        # (ExecutionContext#strategy was used instead)
+        # now it _is_ used, but it breaks GraphQL::Batch tests
+        @execution_strategy ||= new_strategy
       end
 
       # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
       attr_accessor :irep_node
 
+      # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
+      def ast_node
+        @irep_node.ast_node
+      end
+
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
 
@@ -25,6 +32,9 @@ module GraphQL
       # @return [GraphQL::Schema::Mask::Warden]
       attr_reader :warden
 
+      # @return [Array<String, Integer>] The current position in the result
+      attr_reader :path
+
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
@@ -34,6 +44,7 @@ module GraphQL
         @values = values || {}
         @errors = []
         @warden = query.warden
+        @path = []
       end
 
       # Lookup `key` from the hash passed to {Schema#execute} as `context:`
@@ -45,6 +56,43 @@ module GraphQL
       def []=(key, value)
         @values[key] = value
       end
+
+      def spawn(path:, irep_node:)
+        FieldResolutionContext.new(context: self, path: path, irep_node: irep_node)
+      end
+
+      class FieldResolutionContext
+        extend Forwardable
+
+        attr_reader :path, :irep_node
+
+        def initialize(context:, path:, irep_node:)
+          @context = context
+          @path = path
+          @irep_node = irep_node
+        end
+
+        def_delegators :@context, :[], :[]=, :spawn, :query, :schema, :warden, :errors, :execution_strategy
+
+        # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
+        def ast_node
+          @irep_node.ast_node
+        end
+
+        # Add error to current field resolution.
+        # @param error [GraphQL::ExecutionError] an execution error
+        # @return [void]
+        def add_error(error)
+          unless error.is_a?(ExecutionError)
+            raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+          end
+
+          error.ast_node ||= irep_node.ast_node
+          error.path ||= path
+          errors << error
+          nil
+        end
+      end
     end
   end
 end

data/lib/graphql/query/serial_execution.rb

@@ -1,4 +1,3 @@
-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"
@@ -18,11 +17,11 @@ module GraphQL
       def execute(ast_operation, root_type, query_object)
         irep_root = query_object.internal_representation[ast_operation.name]
 
-        operation_resolution.new(
+        operation_resolution.resolve(
           irep_root,
           root_type,
-          ExecutionContext.new(query_object, self)
-        ).result
+          query_object
+        )
       end
 
       def field_resolution

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

@@ -2,15 +2,17 @@ module GraphQL
   class Query
     class SerialExecution
       class FieldResolution
-        attr_reader :irep_node, :parent_type, :target, :execution_context, :field, :arguments
+        attr_reader :irep_node, :parent_type, :target, :field, :arguments, :query
 
-        def initialize(irep_node, parent_type, target, execution_context)
-          @irep_node = irep_node
+        def initialize(irep_nodes, parent_type, target, query_ctx)
+          @irep_node = irep_nodes.first
+          @irep_nodes = irep_nodes
           @parent_type = parent_type
           @target = target
-          @execution_context = execution_context
-          @field = execution_context.get_field(parent_type, irep_node)
-          @arguments = execution_context.query.arguments_for(irep_node, @field)
+          @field_ctx = query_ctx.spawn(path: query_ctx.path + [irep_node.name], irep_node: irep_node)
+          @query = query_ctx.query
+          @field = @query.get_field(parent_type, irep_node.definition_name)
+          @arguments = @query.arguments_for(irep_node, @field)
         end
 
         def result
@@ -19,6 +21,11 @@ module GraphQL
           { result_name => get_finished_value(raw_value) }
         end
 
+        # GraphQL::Batch depends on this
+        def execution_context
+          @field_ctx
+        end
+
         private
 
         # After getting the value from the field's resolve method,
@@ -27,15 +34,15 @@ module GraphQL
           case raw_value
           when GraphQL::ExecutionError
             raw_value.ast_node = irep_node.ast_node
-            raw_value.path = irep_node.path
-            execution_context.add_error(raw_value)
+            raw_value.path = @field_ctx.path
+            @query.context.errors.push(raw_value)
           when Array
             list_errors = raw_value.each_with_index.select { |value, _| value.is_a?(GraphQL::ExecutionError) }
             if list_errors.any?
               list_errors.each do |error, index|
                 error.ast_node = irep_node.ast_node
-                error.path = irep_node.path + [index]
-                execution_context.add_error(error)
+                error.path = @field_ctx.path + [index]
+                @query.context.errors.push(error)
               end
             end
           end
@@ -46,14 +53,14 @@ module GraphQL
               field,
               field.type,
               raw_value,
-              irep_node,
-              execution_context,
+              @irep_nodes,
+              @field_ctx,
             )
           rescue GraphQL::InvalidNullError => err
             if field.type.kind.non_null?
               raise(err)
             else
-              err.parent_error? || execution_context.add_error(err)
+              err.parent_error? || @query.context.errors.push(err)
               nil
             end
           end
@@ -65,34 +72,26 @@ module GraphQL
         # If the middleware chain returns a GraphQL::ExecutionError, its message
         # is added to the "errors" key.
         def get_raw_value
-          middlewares = execution_context.query.schema.middleware
-          query_context = execution_context.query.context
-          # setup
-          query_context.irep_node = @irep_node
+          middlewares = @query.schema.middleware
 
-          resolve_arguments = [parent_type, target, field, arguments, query_context]
+          resolve_arguments = [parent_type, target, field, arguments, @field_ctx]
 
-          resolve_value = begin
-              # only run a middleware chain if there are any middleware
-              if middlewares.any?
-                chain = GraphQL::Schema::MiddlewareChain.new(
-                  steps: middlewares + [FieldResolveStep],
-                  arguments: resolve_arguments
-                )
-                chain.call
-              else
-                FieldResolveStep.call(*resolve_arguments)
-              end
-            rescue GraphQL::ExecutionError => err
-              err
+          begin
+            # only run a middleware chain if there are any middleware
+            if middlewares.any?
+              chain = GraphQL::Schema::MiddlewareChain.new(
+                steps: middlewares + [FieldResolveStep],
+                arguments: resolve_arguments
+              )
+              chain.call
+            else
+              FieldResolveStep.call(*resolve_arguments)
             end
-        ensure
-          # teardown
-          query_context.irep_node = nil
-          resolve_value
+          rescue GraphQL::ExecutionError => err
+            err
+          end
         end
 
-
         # A `.call`-able suitable to be the last step in a middleware chain
         module FieldResolveStep
           # Execute the field's resolve method

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

@@ -1,24 +1,18 @@
 module GraphQL
   class Query
     class SerialExecution
-      class OperationResolution
-        attr_reader :target, :execution_context, :irep_node
-
-        def initialize(irep_node, target, execution_context)
-          @target = target
-          @irep_node = irep_node
-          @execution_context = execution_context
-        end
-
-        def result
-          execution_context.strategy.selection_resolution.resolve(
-            execution_context.query.root_value,
+      module OperationResolution
+        def self.resolve(irep_node, target, query)
+          result = query.context.execution_strategy.selection_resolution.resolve(
+            query.root_value,
             target,
-            irep_node,
-            execution_context
+            [irep_node],
+            query.context,
           )
+
+          result
         rescue GraphQL::InvalidNullError => err
-          err.parent_error? || execution_context.add_error(err)
+          err.parent_error? || query.context.errors.push(err)
           nil
         end
       end

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

@@ -2,18 +2,21 @@ module GraphQL
   class Query
     class SerialExecution
       module SelectionResolution
-        def self.resolve(target, current_type, irep_node, execution_context)
-          irep_node.children.each_with_object({}) do |(name, irep_node), memo|
-            if irep_node.included? && irep_node.definitions.any? { |potential_type, field_defn| GraphQL::Execution::Typecast.compatible?(current_type, potential_type, execution_context.query.context) }
-              field_result = execution_context.strategy.field_resolution.new(
-                irep_node,
-                current_type,
-                target,
-                execution_context
-              ).result
-              memo.merge!(field_result)
-            end
+        def self.resolve(target, current_type, irep_nodes, query_ctx)
+          own_selections = query_ctx.query.selections(irep_nodes, current_type)
+
+          selection_result = {}
+
+          own_selections.each do |name, child_irep_nodes|
+            selection_result.merge!(query_ctx.execution_strategy.field_resolution.new(
+              child_irep_nodes,
+              current_type,
+              target,
+              query_ctx
+            ).result)
           end
+
+          selection_result
         end
       end
     end

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

@@ -2,7 +2,7 @@ module GraphQL
   class Query
     class SerialExecution
       module ValueResolution
-        def self.resolve(parent_type, field_defn, field_type, value, irep_node, execution_context)
+        def self.resolve(parent_type, field_defn, field_type, value, irep_nodes, query_ctx)
           if value.nil? || value.is_a?(GraphQL::ExecutionError)
             if field_type.kind.non_null?
               raise GraphQL::InvalidNullError.new(parent_type.name, field_defn.name, value)
@@ -14,21 +14,21 @@ module GraphQL
             when GraphQL::TypeKinds::SCALAR
               field_type.coerce_result(value)
             when GraphQL::TypeKinds::ENUM
-              field_type.coerce_result(value, execution_context.query.warden)
+              field_type.coerce_result(value, query_ctx.query.warden)
             when GraphQL::TypeKinds::LIST
               wrapped_type = field_type.of_type
               result = value.each_with_index.map do |inner_value, index|
-                irep_node.index = index
-                resolve(
+                inner_ctx = query_ctx.spawn(path: query_ctx.path + [index], irep_node: query_ctx.irep_node)
+                inner_result = resolve(
                   parent_type,
                   field_defn,
                   wrapped_type,
                   inner_value,
-                  irep_node,
-                  execution_context,
+                  irep_nodes,
+                  inner_ctx,
                 )
+                inner_result
               end
-              irep_node.index = nil
               result
             when GraphQL::TypeKinds::NON_NULL
               wrapped_type = field_type.of_type
@@ -37,30 +37,31 @@ module GraphQL
                 field_defn,
                 wrapped_type,
                 value,
-                irep_node,
-                execution_context,
+                irep_nodes,
+                query_ctx,
               )
             when GraphQL::TypeKinds::OBJECT
-              execution_context.strategy.selection_resolution.resolve(
+              query_ctx.execution_strategy.selection_resolution.resolve(
                 value,
                 field_type,
-                irep_node,
-                execution_context
+                irep_nodes,
+                query_ctx
               )
             when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
-              resolved_type = execution_context.schema.resolve_type(value, execution_context.query.context)
-              possible_types = execution_context.possible_types(field_type)
+              query = query_ctx.query
+              resolved_type = query.resolve_type(value)
+              possible_types = query.possible_types(field_type)
 
               if !possible_types.include?(resolved_type)
-                raise GraphQL::UnresolvedTypeError.new(irep_node.definition_name, field_type, parent_type, resolved_type, possible_types)
+                raise GraphQL::UnresolvedTypeError.new(irep_nodes.first.definition_name, field_type, parent_type, resolved_type, possible_types)
               else
                 resolve(
                   parent_type,
                   field_defn,
                   resolved_type,
                   value,
-                  irep_node,
-                  execution_context,
+                  irep_nodes,
+                  query_ctx,
                 )
               end
             else

data/lib/graphql/query/variables.rb

@@ -39,7 +39,7 @@ module GraphQL
         validation_result = variable_type.validate_input(provided_value, @warden)
         if !validation_result.valid?
           @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
-        elsif provided_value.nil?
+        elsif !@provided_variables.key?(variable_name) && provided_value.nil?
           GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
         else
           variable_type.coerce_input(provided_value)