graphql 1.2.6 → 1.3.0

data/lib/graphql/language/nodes.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Language
     module Nodes

data/lib/graphql/language/token.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Language
     # Emitted by the lexer and passed to the parser.

data/lib/graphql/language/visitor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Language
     # Depth-first traversal through the tree, calling hooks at each stop.

data/lib/graphql/list_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # A list type modifies another type.
   #

data/lib/graphql/non_null_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # A non-null type modifies another type.
   #
@@ -11,7 +12,7 @@ module GraphQL
   #   # or
   #   field :items, ItemType.to_non_null_type
   #
-  # (If the application fails to return a value, {InvalidNullError} will be raised.)
+  # (If the application fails to return a value, {InvalidNullError} will be passed to {Schema#type_error}.)
   #
   # For input types, it says that the incoming value _must_ be provided by the query.
   #

data/lib/graphql/object_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # This type exposes fields on an object.
   #
@@ -38,6 +39,13 @@ module GraphQL
       @dirty_interfaces = []
     end
 
+    def initialize_copy(other)
+      super
+      @clean_interfaces = nil
+      @dirty_interfaces = other.dirty_interfaces.dup
+      @fields = other.fields.dup
+    end
+
     # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
     def interfaces=(new_interfaces)
       @clean_interfaces = nil
@@ -68,6 +76,10 @@ module GraphQL
       interface_fields.merge(self.fields).values
     end
 
+    protected
+
+    attr_reader :dirty_interfaces
+
     private
 
     # Create a {name => defn} hash for fields inherited from interfaces

data/lib/graphql/query.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "graphql/query/arguments"
 require "graphql/query/context"
 require "graphql/query/executor"
@@ -25,7 +26,7 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :max_depth, :query_string, :warden
+    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :max_depth, :query_string, :warden, :provided_variables
 
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
@@ -82,22 +83,43 @@ module GraphQL
       # Trying to execute a document
       # with no operations returns an empty hash
       @ast_variables = []
+      @mutation = false
       if @operations.any?
         @selected_operation = find_operation(@operations, @operation_name)
         if @selected_operation.nil?
           @validation_errors << GraphQL::Query::OperationNameMissingError.new(@operations.keys)
         else
           @ast_variables = @selected_operation.variables
+          @mutation = @selected_operation.operation_type == "mutation"
         end
       end
+      @result = nil
+      @executed = false
     end
 
     # Get the result for this query, executing it once
+    # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
-      @result ||= begin
+      if @executed
+        @result
+      else
+        @executed = true
         instrumenters = @schema.instrumenters[:query]
-        execution_call = ExecutionCall.new(self, instrumenters)
-        execution_call.call
+        begin
+          instrumenters.each { |i| i.before_query(self) }
+          @result = if !valid?
+            all_errors = validation_errors + analysis_errors
+            if all_errors.any?
+              { "errors" => all_errors.map(&:to_h) }
+            else
+              nil
+            end
+          else
+            Executor.new(self).result
+          end
+        ensure
+          instrumenters.each { |i| i.after_query(self) }
+        end
       end
     end
 
@@ -132,6 +154,14 @@ module GraphQL
       @internal_representation
     end
 
+    def irep_selection
+      @selection ||= begin
+        irep_root = internal_representation[selected_operation.name]
+        GraphQL::InternalRepresentation::Selection.new(query: self, nodes: [irep_root])
+      end
+    end
+
+
     # TODO this should probably contain error instances, not hashes
     # @return [Array<Hash>] Static validation errors for the query string
     def validation_errors
@@ -171,17 +201,13 @@ 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)
+      @fields ||= Hash.new { |h, k| h[k] = Hash.new { |h2, k2| h2[k2] = @warden.get_field(k, k2) } }
+      @fields[type][name]
     end
 
     def possible_types(type)
@@ -192,6 +218,10 @@ module GraphQL
       @schema.resolve_type(type, @context)
     end
 
+    def mutation?
+      @mutation
+    end
+
     private
 
     # Assert that the passed-in query string is internally consistent
@@ -227,38 +257,5 @@ module GraphQL
         operations[operation_name]
       end
     end
-
-    class ExecutionCall
-      def initialize(query, instrumenters)
-        @query = query
-        @instrumenters = instrumenters
-      end
-
-      # Check if the query is valid, and if it is,
-      # execute it, calling instrumenters along the way
-      # @return [Hash] The GraphQL response
-      def call
-        @instrumenters.each { |i| i.before_query(@query) }
-        result = get_result
-      ensure
-        @instrumenters.each { |i| i.after_query(@query) }
-        result
-      end
-
-      private
-
-      def get_result
-        if !@query.valid?
-          all_errors = @query.validation_errors + @query.analysis_errors
-          if all_errors.any?
-            { "errors" => all_errors.map(&:to_h) }
-          else
-            nil
-          end
-        else
-          Executor.new(@query).result
-        end
-      end
-    end
   end
 end

data/lib/graphql/query/arguments.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     # Read-only access to values, normalizing all keys to strings

data/lib/graphql/query/context.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     # Expose some query-specific info to field resolve functions.
@@ -59,33 +60,46 @@ module GraphQL
         @values[key] = value
       end
 
-      def spawn(path:, irep_node:)
-        FieldResolutionContext.new(context: self, path: path, irep_node: irep_node)
+      def spawn(key:, selection:, parent_type:, field:)
+        FieldResolutionContext.new(
+          context: self,
+          path: path + [key],
+          selection: selection,
+          parent_type: parent_type,
+          field: field,
+        )
       end
 
       class FieldResolutionContext
         extend Forwardable
 
-        attr_reader :path, :irep_node
+        attr_reader :path, :selection, :field, :parent_type
 
-        def initialize(context:, path:, irep_node:)
+        def initialize(context:, path:, selection:, field:, parent_type:)
           @context = context
           @path = path
-          @irep_node = irep_node
+          @selection = selection
+          @field = field
+          @parent_type = parent_type
         end
 
         def_delegators :@context, :[], :[]=, :spawn, :query, :schema, :warden, :errors, :execution_strategy, :strategy
 
         # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
         def ast_node
-          @irep_node.ast_node
+          selection.irep_node.ast_node
+        end
+
+        # @return [GraphQL::InternalRepresentation::Node]
+        def irep_node
+          selection.irep_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)
+          if !error.is_a?(ExecutionError)
             raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
           end
 
@@ -94,6 +108,16 @@ module GraphQL
           errors << error
           nil
         end
+
+        def spawn(key:, selection:, parent_type:, field:)
+          FieldResolutionContext.new(
+            context: @context,
+            path: path + [key],
+            selection: selection,
+            parent_type: parent_type,
+            field: field,
+          )
+        end
       end
     end
   end

data/lib/graphql/query/executor.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class Executor
+      class PropagateNull < StandardError; end
+
       # @return [GraphQL::Query] the query being executed
       attr_reader :query
 
@@ -30,7 +33,11 @@ module GraphQL
         execution_strategy = execution_strategy_class.new
 
         query.context.execution_strategy = execution_strategy
-        data_result = execution_strategy.execute(operation, root_type, query)
+        data_result = begin
+          execution_strategy.execute(operation, root_type, query)
+        rescue PropagateNull
+          nil
+        end
         result = { "data" => data_result }
         error_result = query.context.errors.map(&:to_h)
 

data/lib/graphql/query/input_validation_result.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class InputValidationResult

data/lib/graphql/query/literal_input.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     # Turn query string values into something useful for query execution

data/lib/graphql/query/serial_execution.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "graphql/query/serial_execution/value_resolution"
 require "graphql/query/serial_execution/field_resolution"
 require "graphql/query/serial_execution/operation_resolution"
@@ -12,13 +13,11 @@ module GraphQL
       #
       # @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
+      # @param query_object [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_object)
-        irep_root = query_object.internal_representation[ast_operation.name]
-
         operation_resolution.resolve(
-          irep_root,
+          query_object.irep_selection,
           root_type,
           query_object
         )

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

@@ -1,17 +1,23 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class SerialExecution
       class FieldResolution
         attr_reader :irep_node, :parent_type, :target, :field, :arguments, :query
 
-        def initialize(irep_nodes, parent_type, target, query_ctx)
-          @irep_node = irep_nodes.first
-          @irep_nodes = irep_nodes
+        def initialize(selection, parent_type, target, query_ctx)
+          @irep_node = selection.irep_node
+          @selection = selection
           @parent_type = parent_type
           @target = target
-          @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)
+          @field_ctx = query_ctx.spawn(
+            key: irep_node.name,
+            selection: selection,
+            parent_type: parent_type,
+            field: field,
+          )
           @arguments = @query.arguments_for(irep_node, @field)
         end
 
@@ -33,14 +39,14 @@ module GraphQL
         def get_finished_value(raw_value)
           case raw_value
           when GraphQL::ExecutionError
-            raw_value.ast_node = irep_node.ast_node
+            raw_value.ast_node = @field_ctx.ast_node
             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.ast_node = @field_ctx.ast_node
                 error.path = @field_ctx.path + [index]
                 @query.context.errors.push(error)
               end
@@ -53,14 +59,13 @@ module GraphQL
               field,
               field.type,
               raw_value,
-              @irep_nodes,
+              @selection,
               @field_ctx,
             )
-          rescue GraphQL::InvalidNullError => err
+          rescue GraphQL::Query::Executor::PropagateNull
             if field.type.kind.non_null?
-              raise(err)
+              raise
             else
-              err.parent_error? || @query.context.errors.push(err)
               nil
             end
           end

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

@@ -1,19 +1,17 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class SerialExecution
       module OperationResolution
-        def self.resolve(irep_node, target, query)
+        def self.resolve(selection, target, query)
           result = query.context.execution_strategy.selection_resolution.resolve(
             query.root_value,
             target,
-            [irep_node],
+            selection,
             query.context,
           )
 
           result
-        rescue GraphQL::InvalidNullError => err
-          err.parent_error? || query.context.errors.push(err)
-          nil
         end
       end
     end

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

@@ -1,15 +1,14 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class SerialExecution
       module SelectionResolution
-        def self.resolve(target, current_type, irep_nodes, query_ctx)
-          own_selections = query_ctx.query.selections(irep_nodes, current_type)
-
+        def self.resolve(target, current_type, selection, query_ctx)
           selection_result = {}
 
-          own_selections.each do |name, child_irep_nodes|
+          selection.each_selection(type: current_type) do |name, subselection|
             selection_result.merge!(query_ctx.execution_strategy.field_resolution.new(
-              child_irep_nodes,
+              subselection,
               current_type,
               target,
               query_ctx