graphql 1.5.15 → 1.6.0

data/lib/graphql/execution/field_result.rb

@@ -21,6 +21,7 @@ module GraphQL
       # If it is {Execute::PROPAGATE_NULL}, tell the owner to propagate null.
       # If the value is a {SelectionResult}, make a link with it, and if it's already null,
       # propagate the null as needed.
+      # If it's {Execute::Execution::SKIP}, remove this field result from its parent
       # @param new_value [Any] The GraphQL-ready value
       def value=(new_value)
         if new_value.is_a?(SelectionResult)
@@ -31,12 +32,15 @@ module GraphQL
           end
         end
 
-        if new_value == GraphQL::Execution::Execute::PROPAGATE_NULL
+        case new_value
+        when GraphQL::Execution::Execute::PROPAGATE_NULL
           if @type.kind.non_null?
             @owner.propagate_null
           else
             @value = nil
           end
+        when GraphQL::Execution::Execute::SKIP
+          @owner.delete(self)
         else
           @value = new_value
         end

data/lib/graphql/execution/lazy.rb

@@ -40,9 +40,9 @@ module GraphQL
       end
 
       # @return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in `block`
-      def then
+      def then(&block)
         self.class.new {
-          yield(value)
+          block.call(value)
         }
       end
     end

data/lib/graphql/execution/lazy/resolve.rb

@@ -14,10 +14,8 @@ module GraphQL
 
         def self.resolve_in_place(value)
           lazies = []
-          acc = []
-          each_lazy(acc, value)
 
-          acc.each do |field_result|
+          each_lazy(value) do |field_result|
             inner_lazy = field_result.value.then do |inner_v|
               field_result.value = inner_v
               resolve_in_place(inner_v)
@@ -28,26 +26,25 @@ module GraphQL
           Lazy.new { lazies.map(&:value) }
         end
 
-        # If `value` is a collection,
-        # add any {Lazy} instances in the collection
-        # to `acc`
+        # If `value` is a collection, call `block`
+        # with any {Lazy} instances in the collection
         # @return [void]
-        def self.each_lazy(acc, value)
+        def self.each_lazy(value, &block)
           case value
           when SelectionResult
             value.each do |key, field_result|
-              each_lazy(acc, field_result)
+              each_lazy(field_result, &block)
             end
           when Array
             value.each do |field_result|
-              each_lazy(acc, field_result)
+              each_lazy(field_result, &block)
             end
           when FieldResult
             field_value = value.value
             if field_value.is_a?(Lazy)
-              acc << value
+              yield(value)
             else
-              each_lazy(acc, field_value)
+              each_lazy(field_value, &block)
             end
           end
         end

data/lib/graphql/execution/multiplex.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # Execute multiple queries under the same multiplex "umbrella".
+    # They can share a batching context and reduce redundant database hits.
+    #
+    # The flow is:
+    #
+    # - Multiplex instrumentation setup
+    # - Query instrumentation setup
+    # - Analyze the multiplex + each query
+    # - Begin each query
+    # - Resolve lazy values, breadth-first across all queries
+    # - Finish each query (eg, get errors)
+    # - Query instrumentation teardown
+    # - Multiplex instrumentation teardown
+    #
+    # If one query raises an application error, all queries will be in undefined states.
+    #
+    # Validation errors and {GraphQL::ExecutionError}s are handled in isolation:
+    # one of these errors in one query will not affect the other queries.
+    #
+    # @see {Schema#multiplex} for public API
+    # @api private
+    class Multiplex
+      # Used internally to signal that the query shouldn't be executed
+      # @api private
+      NO_OPERATION = {}.freeze
+
+      attr_reader :context, :queries, :schema
+      def initialize(schema:, queries:, context:)
+        @schema = schema
+        @queries = queries
+        @context = context
+      end
+
+      class << self
+        def run_all(schema, query_options, *rest)
+          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, opts) }
+          run_queries(schema, queries, *rest)
+        end
+
+        def run_queries(schema, queries, context: {}, max_complexity: nil)
+          query_instrumenters = schema.instrumenters[:query]
+          multiplex_instrumenters = schema.instrumenters[:multiplex]
+          multiplex = self.new(schema: schema, queries: queries, context: context)
+
+          # First, run multiplex instrumentation, then query instrumentation for each query
+          multiplex_instrumenters.each { |i| i.before_multiplex(multiplex) }
+          queries.each do |query|
+            query_instrumenters.each { |i| i.before_query(query) }
+          end
+
+          multiplex_analyzers = schema.multiplex_analyzers
+          if max_complexity ||= schema.max_complexity
+            multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
+          end
+
+          GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
+
+          # Then, do as much eager evaluation of the query as possible
+          results = queries.map do |query|
+            begin_query(query)
+          end
+
+          # Then, work through lazy results in a breadth-first way
+          GraphQL::Execution::Lazy.resolve(results)
+
+          # Then, find all errors and assign the result to the query object
+          results.each_with_index.map do |data_result, idx|
+            query = queries[idx]
+            finish_query(data_result, query)
+          end
+        ensure
+          # Finally, run teardown instrumentation for each query + the multiplex
+          # Use `reverse_each` so instrumenters are treated like a stack
+          queries.each do |query|
+            query_instrumenters.reverse_each { |i| i.after_query(query) }
+          end
+          multiplex_instrumenters.reverse_each { |i| i.after_multiplex(multiplex) }
+        end
+
+        private
+
+        # @param query [GraphQL::Query]
+        # @return [Hash] The initial result (may not be finished if there are lazy values)
+        def begin_query(query)
+          operation = query.selected_operation
+          if operation.nil? || !query.valid?
+            NO_OPERATION
+          else
+            begin
+              op_type = operation.operation_type
+              root_type = query.root_type_for_operation(op_type)
+              GraphQL::Execution::Execute::ExecutionFunctions.resolve_selection(
+                query.root_value,
+                root_type,
+                query.irep_selection,
+                query.context,
+                mutation: query.mutation?
+              )
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              {}
+            end
+          end
+        end
+
+        # @param data_result [Hash] The result for the "data" key, if any
+        # @param query [GraphQL::Query] The query which was run
+        # @return [Hash] final result of this query, including all values and errors
+        def finish_query(data_result, query)
+          # Assign the result so that it can be accessed in instrumentation
+          query.result = if data_result.equal?(NO_OPERATION)
+            if !query.valid?
+              { "errors" => query.static_errors.map(&:to_h) }
+            else
+              {}
+            end
+          else
+            result = { "data" => data_result.to_h }
+            error_result = query.context.errors.map(&:to_h)
+
+            if error_result.any?
+              result["errors"] = error_result
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/selection_result.rb

@@ -38,6 +38,11 @@ module GraphQL
         end
       end
 
+      # TODO this should delete by key, ya dummy
+      def delete(field_result)
+        @storage.delete_if { |k, v| v == field_result }
+      end
+
       # A field has been unexpectedly nullified.
       # Tell the owner {FieldResult} if it is present.
       # Record {#invalid_null} in case an owner is added later.

data/lib/graphql/field.rb

@@ -135,7 +135,7 @@ module GraphQL
       :mutation, :arguments, :complexity, :function,
       :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
       :type, :type=, :name=, :property=, :hash_key=,
-      :relay_node_field, :relay_nodes_field, :default_arguments
+      :relay_node_field, :relay_nodes_field
     )
 
     # @return [Boolean] True if this is the Relay find-by-id field
@@ -193,7 +193,6 @@ module GraphQL
       @resolve_proc = build_default_resolver
       @lazy_resolve_proc = DefaultLazyResolve
       @relay_node_field = false
-      @default_arguments = nil
       @connection = false
       @connection_max_page_size = nil
     end
@@ -201,7 +200,6 @@ module GraphQL
     def initialize_copy(other)
       super
       @arguments = other.arguments.dup
-      @default_arguments = nil
     end
 
     # Get a value for this field
@@ -282,11 +280,6 @@ module GraphQL
       }
     end
 
-    # @return [GraphQL::Query::Arguments] Arguments to use when no args are provided in the query
-    def default_arguments
-      @default_arguments ||= GraphQL::Query::LiteralInput.defaults_for(self.arguments)
-    end
-
     private
 
     def build_default_resolver

data/lib/graphql/filter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module GraphQL
+  # @api private
+  class Filter
+    def initialize(only: nil, except: nil)
+      @only = only
+      @except = except
+    end
+
+    # Returns true if `member, ctx` passes this filter
+    def call(member, ctx)
+      (@only ? @only.call(member, ctx) : true) &&
+      (@except ? !@except.call(member, ctx) : true)
+    end
+
+    def merge(only: nil, except: nil)
+      onlies = [self].concat(Array(only))
+      merged_only = MergedOnly.build(onlies)
+      merged_except = MergedExcept.build(Array(except))
+      self.class.new(only: merged_only, except: merged_except)
+    end
+
+    private
+
+    class MergedOnly
+      def initialize(first, second)
+        @first = first
+        @second = second
+      end
+
+      def call(member, ctx)
+        @first.call(member, ctx) && @second.call(member, ctx)
+      end
+
+      def self.build(onlies)
+        case onlies
+        when 0
+          nil
+        when 1
+          onlies[0]
+        else
+          onlies.reduce { |memo, only| self.new(memo, only) }
+        end
+      end
+    end
+
+    class MergedExcept < MergedOnly
+      def call(member, ctx)
+        @first.call(member, ctx) || @second.call(member, ctx)
+      end
+    end
+  end
+end

data/lib/graphql/internal_representation/node.rb

@@ -2,8 +2,6 @@
 module GraphQL
   module InternalRepresentation
     class Node
-      # @api private
-      DEFAULT_TYPED_CHILDREN = Proc.new { |h, k| h[k] = {} }
       # @return [String] the name this node has in the response
       attr_reader :name
 
@@ -17,13 +15,13 @@ module GraphQL
       # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>]
       def typed_children
         @typed_childen ||= begin
-          new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
+          new_tc = Hash.new { |h, k| h[k] = {} }
           if @scoped_children.any?
             all_object_types = Set.new
             scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }
             # Remove any scoped children which don't follow this return type
             # (This can happen with fragment merging where lexical scope is lost)
-            all_object_types &= @query.possible_types(@return_type)
+            all_object_types &= @query.possible_types(@return_type.unwrap)
             all_object_types.each do |t|
               new_tc[t] = get_typed_children(t)
             end
@@ -47,7 +45,7 @@ module GraphQL
       # @return [Array<GraphQL::Field>] Field definitions for this node (there should only be one!)
       attr_reader :definitions
 
-      # @return [GraphQL::BaseType]
+      # @return [GraphQL::BaseType] The expected wrapped type this node must return.
       attr_reader :return_type
 
       # @return [InternalRepresentation::Node, nil]
@@ -97,6 +95,10 @@ module GraphQL
         definition && definition.name
       end
 
+      def arguments
+        @query.arguments_for(self, definition)
+      end
+
       def definition
         @definition ||= begin
           first_def = @definitions.first
@@ -121,7 +123,7 @@ module GraphQL
           @ast_nodes |= new_parent.ast_nodes
           @definitions |= new_parent.definitions
         end
-        scope ||= Scope.new(@query, @return_type)
+        scope ||= Scope.new(@query, @return_type.unwrap)
         new_parent.scoped_children.each do |obj_type, new_fields|
           inner_scope = scope.enter(obj_type)
           inner_scope.each do |scoped_type|
@@ -138,6 +140,9 @@ module GraphQL
         end
       end
 
+      # @return [GraphQL::Query]
+      attr_reader :query
+
       protected
 
       attr_writer :owner_type, :parent

data/lib/graphql/internal_representation/rewrite.rb

@@ -93,7 +93,7 @@ module GraphQL
               # It's a non-existent field
               new_scope = nil
             else
-              field_return_type = field_defn.type.unwrap
+              field_return_type = field_defn.type
               scopes_stack.last.each do |scope_type|
                 parent_nodes.each do |parent_node|
                   node = parent_node.scoped_children[scope_type][node_name] ||= Node.new(
@@ -108,7 +108,7 @@ module GraphQL
                   next_nodes << node
                 end
               end
-              new_scope = Scope.new(query, field_return_type)
+              new_scope = Scope.new(query, field_return_type.unwrap)
             end
 
             nodes_stack.push(next_nodes)
@@ -181,7 +181,7 @@ module GraphQL
             owner_type: owner_type,
             query: @query,
             ast_nodes: [ast_node],
-            return_type: owner_type,
+            return_type: @context.type_definition,
           )
 
           @definitions[defn_name] = node

data/lib/graphql/query.rb

@@ -14,7 +14,7 @@ require "graphql/query/validation_pipeline"
 module GraphQL
   # A combination of query string and {Schema} instance which can be reduced to a {#result}.
   class Query
-    extend GraphQL::Delegate
+    extend Forwardable
 
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)
@@ -27,7 +27,19 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :query_string, :warden, :provided_variables, :operation_name
+    attr_reader :schema, :context, :root_value, :warden, :provided_variables
+
+    attr_accessor :query_string
+
+    # @return [GraphQL::Language::Nodes::Document]
+    def document
+      with_prepared_ast { @document }
+    end
+
+    # @return [String, nil] The name of the operation to run (may be inferred)
+    def operation_name
+      with_prepared_ast { @operation_name }
+    end
 
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
@@ -40,39 +52,23 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
-      fail ArgumentError, "a query string or document is required" unless query_string || document
-
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
       @schema = schema
-      mask = GraphQL::Schema::Mask.combine(schema.default_mask, except: except, only: only)
+      @filter = schema.default_filter.merge(except: except, only: only)
       @context = Context.new(query: self, values: context)
-      @warden = GraphQL::Schema::Warden.new(mask, schema: @schema, context: @context)
       @root_value = root_value
-      @fragments = {}
-      @operations = {}
+      @fragments = nil
+      @operations = nil
+
+      @analysis_errors = []
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
       else
         @provided_variables = variables
       end
-      @query_string = query_string
-      parse_error = nil
-      @document = document || begin
-        GraphQL.parse(query_string)
-      rescue GraphQL::ParseError => err
-        parse_error = err
-        @schema.parse_error(err, @context)
-        nil
-      end
 
-      @document && @document.definitions.each do |part|
-        case part
-        when GraphQL::Language::Nodes::FragmentDefinition
-          @fragments[part.name] = part
-        when GraphQL::Language::Nodes::OperationDefinition
-          @operations[part.name] = part
-        end
-      end
+      @query_string = query_string || query
+      @document = document
 
       @resolved_types_cache = Hash.new { |h, k| h[k] = @schema.resolve_type(k, @context) }
 
@@ -82,64 +78,56 @@ module GraphQL
       # with no operations returns an empty hash
       @ast_variables = []
       @mutation = false
-      operation_name_error = nil
-      @operation_name = nil
+      @operation_name = operation_name
+      @prepared_ast = false
 
-      if @operations.any?
-        selected_operation = find_operation(@operations, operation_name)
-        if selected_operation.nil?
-          operation_name_error = GraphQL::Query::OperationNameMissingError.new(operation_name)
-        else
-          @operation_name = selected_operation.name
-          @ast_variables = selected_operation.variables
-          @mutation = selected_operation.operation_type == "mutation"
-          @selected_operation = selected_operation
-        end
-      end
-
-      @validation_pipeline = GraphQL::Query::ValidationPipeline.new(
-        query: self,
-        parse_error: parse_error,
-        operation_name_error: operation_name_error,
-        max_depth: max_depth || schema.max_depth,
-        max_complexity: max_complexity || schema.max_complexity,
-      )
+      @validation_pipeline = nil
+      @max_depth = max_depth || schema.max_depth
+      @max_complexity = max_complexity || schema.max_complexity
 
       @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
+    # @api private
+    def result=(result_hash)
       if @executed
-        @result
+        raise "Invariant: Can't reassign result"
       else
         @executed = true
-        instrumenters = @schema.instrumenters[:query]
-        begin
-          instrumenters.each { |i| i.before_query(self) }
-          @result = if !valid?
-            all_errors = validation_errors + analysis_errors + context.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
+        @result = result_hash
+      end
+    end
+
+    def fragments
+      with_prepared_ast { @fragments }
+    end
+
+    def operations
+      with_prepared_ast { @operations }
+    end
+
+    # Get the result for this query, executing it once
+    # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
+    def result
+      if !@executed
+        with_prepared_ast {
+          Execution::Multiplex.run_queries(@schema, [self])
+        }
       end
+      @result
     end
 
+    def static_errors
+      validation_errors + analysis_errors + context.errors
+    end
 
     # This is the operation to run for this query.
     # If more than one operation is present, it must be named at runtime.
     # @return [GraphQL::Language::Nodes::OperationDefinition, nil]
-    attr_reader :selected_operation
+    def selected_operation
+      with_prepared_ast { @selected_operation }
+    end
 
     # Determine the values for variables of this query, using default values
     # if a value isn't provided at runtime.
@@ -149,12 +137,13 @@ module GraphQL
     # @return [GraphQL::Query::Variables] Variables to apply to this query
     def variables
       @variables ||= begin
-        vars = GraphQL::Query::Variables.new(
-          @context,
-          @ast_variables,
-          @provided_variables,
-        )
-        vars
+        with_prepared_ast {
+          GraphQL::Query::Variables.new(
+            @context,
+            @ast_variables,
+            @provided_variables,
+          )
+        }
       end
     end
 
@@ -169,12 +158,27 @@ module GraphQL
       @arguments_cache[irep_or_ast_node][definition]
     end
 
-    # @return [GraphQL::Language::Nodes::Document, nil]
-    attr_reader :selected_operation
+    # @return [GraphQL::Language::Nodes::OperationDefinition, nil]
+    def selected_operation
+      with_prepared_ast { @selected_operation }
+    end
 
-    def_delegators :@validation_pipeline, :valid?, :analysis_errors, :validation_errors, :internal_representation
+    def validation_pipeline
+      with_prepared_ast { @validation_pipeline }
+    end
+
+    def_delegators :validation_pipeline, :validation_errors, :internal_representation, :analyzers
+
+    attr_accessor :analysis_errors
+    def valid?
+      validation_pipeline.valid? && analysis_errors.none?
+    end
+
+    def warden
+      with_prepared_ast { @warden }
+    end
 
-    def_delegators :@warden, :get_type, :get_field, :possible_types, :root_type_for_operation
+    def_delegators :warden, :get_type, :get_field, :possible_types, :root_type_for_operation
 
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}
@@ -187,6 +191,16 @@ module GraphQL
       @mutation
     end
 
+    # @return [void]
+    def merge_filters(only: nil, except: nil)
+      if @prepared_ast
+        raise "Can't add filters after preparing the query"
+      else
+        @filter = @filter.merge(only: only, except: except)
+      end
+      nil
+    end
+
     private
 
     def find_operation(operations, operation_name)
@@ -198,5 +212,73 @@ module GraphQL
         operations.fetch(operation_name)
       end
     end
+
+    def prepare_ast
+      @prepared_ast = true
+      @warden = GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
+
+      parse_error = nil
+      @document ||= begin
+        if query_string
+          GraphQL.parse(query_string)
+        end
+      rescue GraphQL::ParseError => err
+        parse_error = err
+        @schema.parse_error(err, @context)
+        nil
+      end
+
+      @fragments = {}
+      @operations = {}
+      if @document
+        @document.definitions.each do |part|
+          case part
+          when GraphQL::Language::Nodes::FragmentDefinition
+            @fragments[part.name] = part
+          when GraphQL::Language::Nodes::OperationDefinition
+            @operations[part.name] = part
+          end
+        end
+      elsif parse_error
+        # This will be handled later
+      else
+        raise ArgumentError, "a query string or document is required"
+      end
+
+      # Trying to execute a document
+      # with no operations returns an empty hash
+      @ast_variables = []
+      @mutation = false
+      operation_name_error = nil
+      if @operations.any?
+        @selected_operation = find_operation(@operations, @operation_name)
+        if @selected_operation.nil?
+          operation_name_error = GraphQL::Query::OperationNameMissingError.new(@operation_name)
+        else
+          if @operation_name.nil?
+            @operation_name = @selected_operation.name
+          end
+          @ast_variables = @selected_operation.variables
+          @mutation = @selected_operation.operation_type == "mutation"
+        end
+      end
+
+      @validation_pipeline = GraphQL::Query::ValidationPipeline.new(
+        query: self,
+        parse_error: parse_error,
+        operation_name_error: operation_name_error,
+        max_depth: @max_depth,
+        max_complexity: @max_complexity || schema.max_complexity,
+      )
+    end
+
+    # Since the query string is processed at the last possible moment,
+    # any internal values which depend on it should be accessed within this wrapper.
+    def with_prepared_ast
+      if !@prepared_ast
+        prepare_ast
+      end
+      yield
+    end
   end
 end