graphql 0.15.3 → 0.16.0

data/lib/graphql/query/context.rb

@@ -5,10 +5,12 @@ module GraphQL
     class Context
       attr_accessor :execution_strategy
 
-      # The {GraphQL::Language::Nodes::Field} for the currently-executing field.
-      # @return [GraphQL::Language::Nodes::Field]
+      # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
       attr_accessor :ast_node
 
+      # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
+      attr_accessor :irep_node
+
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
 
@@ -28,10 +30,15 @@ module GraphQL
         @errors = []
       end
 
-      # Lookup `key` from the hash passed to {Schema#execute} as `context`
+      # Lookup `key` from the hash passed to {Schema#execute} as `context:`
       def [](key)
         @values[key]
       end
+
+      # Reassign `key` to the hash passed to {Schema#execute} as `context:`
+      def []=(key, value)
+        @values[key] = value
+      end
     end
   end
 end

data/lib/graphql/query/directive_resolution.rb

@@ -1,11 +1,11 @@
 module GraphQL
   class Query
     module DirectiveResolution
-      def self.include_node?(ast_node, query)
-        ast_node.directives.each do |ast_directive|
-          directive = query.schema.directives[ast_directive.name]
-          args = GraphQL::Query::LiteralInput.from_arguments(ast_directive.arguments, directive.arguments, query.variables)
-          if !directive.include?(args)
+      def self.include_node?(irep_node, query)
+        irep_node.directives.each do |directive_node|
+          directive_defn = directive_node.definition
+          args = query.arguments_for(directive_node)
+          if !directive_defn.include?(args)
             return false
           end
         end

data/lib/graphql/query/serial_execution.rb

@@ -9,11 +9,13 @@ module GraphQL
       # @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)
+      def execute(ast_operation, root_type, query_object)
+        irep_root = query_object.internal_representation[ast_operation.name]
+
         operation_resolution.new(
-          ast_operation,
+          irep_root,
           root_type,
-          ExecutionContext.new(query_obj, self)
+          ExecutionContext.new(query_object, self)
         ).result
       end
 

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

@@ -2,28 +2,33 @@ module GraphQL
   class Query
     class SerialExecution
       class FieldResolution
-        attr_reader :ast_node, :parent_type, :target, :execution_context, :field, :arguments
+        attr_reader :irep_node, :parent_type, :target, :execution_context, :field, :arguments
 
-        def initialize(ast_node, parent_type, target, execution_context)
-          @ast_node = ast_node
+        def initialize(irep_node, parent_type, target, execution_context)
+          @irep_node = irep_node
           @parent_type = parent_type
           @target = target
           @execution_context = execution_context
-          @field =  execution_context.get_field(parent_type, ast_node.name)
+          @field = execution_context.get_field(parent_type, irep_node.definition.name)
           if @field.nil?
             raise("No field found on #{parent_type.name} '#{parent_type}' for '#{ast_node.name}'")
           end
-          @arguments = GraphQL::Query::LiteralInput.from_arguments(
-            ast_node.arguments,
-            field.arguments,
-            execution_context.query.variables
-          )
+          @arguments = execution_context.query.arguments_for(irep_node)
         end
 
         def result
-          result_name = ast_node.alias || ast_node.name
-          raw_value = get_raw_value
-          { result_name => get_finished_value(raw_value) }
+          result_name = irep_node.name
+          begin
+            raw_value = get_raw_value
+            { result_name => get_finished_value(raw_value) }
+          rescue GraphQL::InvalidNullError => err
+            if field.type.kind.non_null?
+              raise(err)
+            else
+              err.parent_error? || execution_context.add_error(err)
+              {result_name => nil}
+            end
+          end
         end
 
         private
@@ -32,12 +37,12 @@ module GraphQL
         # continue by "finishing" the value, eg. executing sub-fields or coercing values
         def get_finished_value(raw_value)
           if raw_value.is_a?(GraphQL::ExecutionError)
-            raw_value.ast_node = ast_node
+            raw_value.ast_node = irep_node.ast_node
             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 = strategy_class.new(raw_value, field.type, target, parent_type, irep_node, execution_context)
           result_strategy.result
         end
 
@@ -63,9 +68,11 @@ module GraphQL
         # @return [Proc] suitable to be the last step in a middleware chain
         def get_middleware_proc_from_field_resolve
           -> (_parent_type, parent_object, field_definition, field_args, context, _next) {
-            context.ast_node = ast_node
+            context.ast_node = irep_node.ast_node
+            context.irep_node = irep_node
             value = field_definition.resolve(parent_object, field_args, context)
             context.ast_node = nil
+            context.irep_node = nil
             value
           }
         end

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

@@ -2,22 +2,24 @@ module GraphQL
   class Query
     class SerialExecution
       class OperationResolution
-        attr_reader :target, :ast_operation_definition, :execution_context
+        attr_reader :target, :execution_context, :irep_node
 
-        def initialize(ast_operation_definition, target, execution_context)
-          @ast_operation_definition = ast_operation_definition
+        def initialize(irep_node, target, execution_context)
           @target = target
+          @irep_node = irep_node
           @execution_context = execution_context
         end
 
         def result
-          selections = ast_operation_definition.selections
           execution_context.strategy.selection_resolution.new(
             execution_context.query.root_value,
             target,
-            selections,
+            irep_node,
             execution_context
           ).result
+        rescue GraphQL::InvalidNullError => err
+          err.parent_error? || execution_context.add_error(err)
+          nil
         end
       end
     end

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

@@ -2,124 +2,39 @@ module GraphQL
   class Query
     class SerialExecution
       class SelectionResolution
-        attr_reader :target, :type, :selections, :execution_context
+        attr_reader :target, :type, :irep_node, :execution_context
 
-        def initialize(target, type, selections, execution_context)
+        def initialize(target, type, irep_node, execution_context)
           @target = target
           @type = type
-          @selections = selections
+          @irep_node = irep_node
           @execution_context = execution_context
         end
 
         def result
-          flatten_and_merge_selections(selections)
-            .values
-            .reduce({}) { |result, ast_node|
-              result.merge(resolve_field(ast_node))
-            }
-        rescue GraphQL::InvalidNullError => err
-          err.parent_error? || execution_context.add_error(err)
-          nil
-        end
-
-        private
-
-        def flatten_selection(ast_node)
-          strategy_method = STRATEGIES[ast_node.class]
-          send(strategy_method, ast_node)
-        end
-
-        STRATEGIES = {
-          GraphQL::Language::Nodes::Field => :flatten_field,
-          GraphQL::Language::Nodes::InlineFragment => :flatten_inline_fragment,
-          GraphQL::Language::Nodes::FragmentSpread => :flatten_fragment_spread,
-        }
-
-        def flatten_field(ast_node)
-          result_name = ast_node.alias || ast_node.name
-          { result_name => ast_node }
-        end
-
-        def flatten_inline_fragment(ast_node)
-          return {} unless GraphQL::Query::DirectiveResolution.include_node?(ast_node, execution_context.query)
-          flatten_fragment(ast_node)
-        end
-
-        def flatten_fragment_spread(ast_node)
-          return {} unless GraphQL::Query::DirectiveResolution.include_node?(ast_node, execution_context.query)
-          ast_fragment_defn = execution_context.get_fragment(ast_node.name)
-          flatten_fragment(ast_fragment_defn)
-        end
-
-        def flatten_fragment(ast_fragment)
-          if fragment_type_can_apply?(ast_fragment)
-            flatten_and_merge_selections(ast_fragment.selections)
-          else
-            {}
-          end
-        end
-
-        def fragment_type_can_apply?(ast_fragment)
-          if ast_fragment.type.nil?
-            true
-          else
-            child_type = execution_context.get_type(ast_fragment.type)
-            resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type, execution_context.query.context).type
-            !resolved_type.nil?
-          end
-        end
-
-        def merge_fields(field1, field2)
-          field_type = execution_context.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
+          irep_node.children.each_with_object({}) do |(name, irep_node), memo|
+            if included_by_directives?(irep_node, execution_context.query) && applies_to_type?(irep_node, type, target)
+              field_result = execution_context.strategy.field_resolution.new(
+                irep_node,
+                type,
+                target,
+                execution_context
+              ).result
+              memo.merge!(field_result)
+            end
           end
         end
 
-        def resolve_field(ast_node)
-          return {} unless GraphQL::Query::DirectiveResolution.include_node?(ast_node, execution_context.query)
-          execution_context.strategy.field_resolution.new(
-            ast_node,
-            type,
-            target,
-            execution_context
-          ).result
-        end
-
-        def merge_into_result(memo, selection)
-          name = if selection.respond_to?(:alias)
-            selection.alias || selection.name
-          else
-            selection.name
-          end
+        private
 
-          memo[name] = if memo.key?(name)
-            merge_fields(memo[name], selection)
-          else
-            selection
-          end
+        def included_by_directives?(irep_node, query)
+          GraphQL::Query::DirectiveResolution.include_node?(irep_node, query)
         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
+        def applies_to_type?(irep_node, type, target)
+          irep_node.on_types.any? { |child_type|
+            GraphQL::Query::TypeResolver.new(target, child_type, type, execution_context.query.context).type
+          }
         end
       end
     end

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

@@ -8,13 +8,13 @@ module GraphQL
 
         class BaseResolution
           attr_reader :value, :field_type, :target, :parent_type,
-            :ast_field, :execution_context
-          def initialize(value, field_type, target, parent_type, ast_field, execution_context)
+            :irep_node, :execution_context
+          def initialize(value, field_type, target, parent_type, irep_node, execution_context)
             @value = value
             @field_type = field_type
             @target = target
             @parent_type = parent_type
-            @ast_field = ast_field
+            @irep_node = irep_node
             @execution_context = execution_context
           end
 
@@ -46,7 +46,7 @@ module GraphQL
             wrapped_type = field_type.of_type
             strategy_class = get_strategy_for_kind(wrapped_type.kind)
             value.map do |item|
-              inner_strategy = strategy_class.new(item, wrapped_type, target, parent_type, ast_field, execution_context)
+              inner_strategy = strategy_class.new(item, wrapped_type, target, parent_type, irep_node, execution_context)
               inner_strategy.result
             end
           end
@@ -57,11 +57,11 @@ module GraphQL
             resolved_type = field_type.resolve_type(value, execution_context)
 
             unless resolved_type.is_a?(GraphQL::ObjectType)
-              raise GraphQL::ObjectType::UnresolvedTypeError.new(ast_field.name, field_type, parent_type)
+              raise GraphQL::ObjectType::UnresolvedTypeError.new(irep_node.definition.name, field_type, parent_type)
             end
 
             strategy_class = get_strategy_for_kind(resolved_type.kind)
-            inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, execution_context)
+            inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, irep_node, execution_context)
             inner_strategy.result
           end
         end
@@ -72,7 +72,7 @@ module GraphQL
             execution_context.strategy.selection_resolution.new(
               value,
               field_type,
-              ast_field.selections,
+              irep_node,
               execution_context
             ).result
           end
@@ -81,11 +81,14 @@ module GraphQL
         class NonNullResolution < BaseResolution
           # Get the "wrapped" type and resolve the value according to that type
           def result
-            raise GraphQL::InvalidNullError.new(ast_field.name, value) if value.nil? || value.is_a?(GraphQL::ExecutionError)
-            wrapped_type = field_type.of_type
-            strategy_class = get_strategy_for_kind(wrapped_type.kind)
-            inner_strategy = strategy_class.new(value, wrapped_type, target, parent_type, ast_field, execution_context)
-            inner_strategy.result
+            if value.nil? || value.is_a?(GraphQL::ExecutionError)
+              raise GraphQL::InvalidNullError.new(irep_node.definition.name, value)
+            else
+              wrapped_type = field_type.of_type
+              strategy_class = get_strategy_for_kind(wrapped_type.kind)
+              inner_strategy = strategy_class.new(value, wrapped_type, target, parent_type, irep_node, execution_context)
+              inner_strategy.result
+            end
           end
         end
 

data/lib/graphql/schema.rb

@@ -4,6 +4,7 @@ require "graphql/schema/middleware_chain"
 require "graphql/schema/rescue_middleware"
 require "graphql/schema/possible_types"
 require "graphql/schema/reduce_types"
+require "graphql/schema/timeout_middleware"
 require "graphql/schema/type_expression"
 require "graphql/schema/type_map"
 require "graphql/schema/validation"
@@ -16,8 +17,10 @@ module GraphQL
     DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
-    attr_reader :query, :mutation, :subscription, :directives, :static_validator
+    attr_reader :query, :mutation, :subscription, :directives, :static_validator, :query_analyzers
     attr_accessor :max_depth
+    attr_accessor :max_complexity
+
     # Override these if you don't want the default executor:
     attr_accessor :query_execution_strategy,
       :mutation_execution_strategy,
@@ -31,16 +34,18 @@ module GraphQL
     # @param subscription [GraphQL::ObjectType] the subscription root for the schema
     # @param max_depth [Integer] maximum query nesting (if it's greater, raise an error)
     # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
-    def initialize(query:, mutation: nil, subscription: nil, max_depth: nil, types: [])
+    def initialize(query:, mutation: nil, subscription: nil, max_depth: nil, max_complexity: nil, types: [])
       @query    = query
       @mutation = mutation
       @subscription = subscription
       @max_depth = max_depth
+      @max_complexity = max_complexity
       @orphan_types = types
       @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
       @rescue_middleware = GraphQL::Schema::RescueMiddleware.new
       @middleware = [@rescue_middleware]
+      @query_analyzers = []
       # Default to the built-in execution strategy:
       self.query_execution_strategy = GraphQL::Query::SerialExecution
       self.mutation_execution_strategy = GraphQL::Query::SerialExecution

data/lib/graphql/schema/timeout_middleware.rb

@@ -0,0 +1,67 @@
+module GraphQL
+  class Schema
+    # This middleware will stop resolving new fields after `max_seconds` have elapsed.
+    # After the time has passed, any remaining fields will be `nil`, with errors added
+    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
+    # you'll get a partial response.
+    #
+    # You can provide a block which will be called with any timeout errors that occur.
+    #
+    # Note that this will stop a query _in between_ field resolutions, but
+    # it doesn't interrupt long-running `resolve` functions. Be sure to use
+    # timeout options for external connections. For more info, see
+    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
+    #
+    # @example Stop resolving fields after 2 seconds
+    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2)
+    #
+    # @example Notifying Bugsnag on a timeout
+    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware(max_seconds: 1.5) do |timeout_error, query|
+    #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
+    #   end
+    #
+    class TimeoutMiddleware
+      # This key is used for storing timeout data in the {Query::Context} instance
+      DEFAULT_CONTEXT_KEY = :__timeout_at__
+      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+      # @param context_key [Symbol] what key should be used to read and write to the query context
+      def initialize(max_seconds:, context_key: DEFAULT_CONTEXT_KEY, &block)
+        @max_seconds = max_seconds
+        @context_key = context_key
+        @error_handler = block
+      end
+
+      def call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
+        timeout_at = query_context[@context_key] ||= Time.now + @max_seconds
+        if timeout_at < Time.now
+          on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
+        else
+          next_middleware.call
+        end
+      end
+
+      # This is called when a field _would_ be resolved, except that we're over the time limit.
+      # @return [GraphQL::Schema::TimeoutMiddleware::TimeoutError] An error whose message will be added to the `errors` key
+      def on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
+        err = GraphQL::Schema::TimeoutMiddleware::TimeoutError.new(parent_type, field_definition)
+        if @error_handler
+          @error_handler.call(err, query_context.query)
+        end
+        err
+      end
+    end
+
+    # This error is raised when a query exceeds `max_seconds`.
+    # Since it's a child of {GraphQL::ExecutionError},
+    # its message will be added to the response's `errors` key.
+    #
+    # To raise an error that will stop query resolution, use a custom block
+    # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
+    # such as `RuntimeError`.
+    class GraphQL::Schema::TimeoutMiddleware::TimeoutError < GraphQL::ExecutionError
+      def initialize(parent_type, field_defn)
+        super("Timeout on #{parent_type.name}.#{field_defn.name}")
+      end
+    end
+  end
+end