graphql 1.6.2 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dcc96523b4e6938e39aeae90c15728985618c95b
-  data.tar.gz: da73ad353f7891bf9f4146e8941200747a928c39
+  metadata.gz: b8eca19d9b215aed67ef5434bb5dab5cce3e8626
+  data.tar.gz: 66740ce037cbd8e4019ed7516503e430ebb0a34a
 SHA512:
-  metadata.gz: b709b3b6833dd60102f6bfa7ebc7efd7a1a36ef7af8b0aa5723b1b421cc4c14516ef2480d058c885d9fb9de34013c0e3d0e6d0bbaa22850df7ff2bf9c50535c8
-  data.tar.gz: 0a4b99378090cfbce6916a725ccadb8b91238cbeaf8a00c28e0fcbcedc43d1b8c238b3f2c502ece948e5379a2d33cb2265e8210c2e44ae466d570f177fb44059
+  metadata.gz: 6e34b8bce773c1304d9c4796a20a92c731de182ad1a144df2bb4a814295a2233b298d8817d24c96837540b57fd73ca3a9acb55b286308c1b7a3b3725f31c3e11
+  data.tar.gz: b9cce7a863dfaabcb7312a0844ef659504cf5adedfe7b22246ce4856ae78d71c6204535a1351b5d0c746161b5155d06cd25f845a0d8fdc3776a9ee27ed41160d

data/lib/graphql.rb

@@ -3,9 +3,26 @@ require "delegate"
 require "json"
 require "set"
 require "singleton"
-require "forwardable"
 
 module GraphQL
+  # Ruby stdlib was pretty busted until this fix:
+  # https://github.com/ruby/ruby/commit/46c0e79bb5b96c45c166ef62f8e585f528862abb#diff-43adf0e587a50dbaf51764a262008d40
+  module Delegate
+    def def_delegators(accessor, *method_names)
+      method_names.each do |method_name|
+        class_eval <<-RUBY
+        def #{method_name}(*args)
+          if block_given?
+            #{accessor}.#{method_name}(*args, &Proc.new)
+          else
+            #{accessor}.#{method_name}(*args)
+          end
+        end
+        RUBY
+      end
+    end
+  end
+
   class Error < StandardError
   end
 

data/lib/graphql/analysis/query_complexity.rb

@@ -69,7 +69,7 @@ module GraphQL
       # Find the maximum possible complexity among those combinations.
       class TypeComplexity
         def initialize
-          @types = Hash.new { |h, k| h[k] = 0 }
+          @types = Hash.new(0)
         end
 
         # Return the max possible complexity for types in this selection

data/lib/graphql/backwards_compatibility.rb

@@ -25,7 +25,7 @@ module GraphQL
 
     def get_arity(callable)
       case callable
-      when Proc
+      when Method, Proc
         callable.arity
       else
         callable.method(:call).arity

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -66,9 +66,9 @@ module GraphQL
             |
             res = self.class.lazy_schema.execute(query_str, context: {pushes: []})
             assert_equal nil, res["data"]
-            assert_equal 2, res["errors"].length
+            # The first fail causes the second field to never resolve
+            assert_equal 1, res["errors"].length
             assert_equal ["push", "push", "fail1", "value"], res["errors"][0]["path"]
-            assert_equal ["push", "push", "fail2", "value"], res["errors"][1]["path"]
           end
 
           def test_it_resolves_mutation_values_eagerly

data/lib/graphql/execution/execute.rb

@@ -4,8 +4,14 @@ module GraphQL
     # A valid execution strategy
     # @api private
     class Execute
+
       # @api private
-      SKIP = Object.new
+      class Skip; end
+
+      # Just a singleton for implementing {Query::Context#skip}
+      # @api private
+      SKIP = Skip.new
+
       # @api private
       PROPAGATE_NULL = Object.new
 
@@ -40,7 +46,7 @@ module GraphQL
               query_ctx
             )
 
-            if field_result == SKIP
+            if field_result.is_a?(Skip)
               next
             end
 
@@ -103,6 +109,9 @@ module GraphQL
         end
 
         def continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
+          if owner.invalid_null?
+            return
+          end
           query = field_ctx.query
 
           case raw_value
@@ -147,7 +156,7 @@ module GraphQL
             else
               nil
             end
-          elsif value == SKIP
+          elsif value.is_a?(Skip)
             value
           else
             case field_type.kind

data/lib/graphql/execution/lazy.rb

@@ -40,11 +40,16 @@ module GraphQL
       end
 
       # @return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in `block`
-      def then(&block)
+      def then
         self.class.new {
-          block.call(value)
+          yield(value)
         }
       end
+
+      # This can be used for fields which _had no_ lazy results
+      # @api private
+      NullResult = Lazy.new(){}
+      NullResult.value
     end
   end
 end

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

@@ -51,7 +51,7 @@ module GraphQL
 
         # Mock the Concurrent::Map API
         class ConcurrentishMap
-          extend Forwardable
+          extend GraphQL::Delegate
           # Technically this should be under the mutex too,
           # but I know it's only used when the lock is already acquired.
           def_delegators :@storage, :each_pair, :size

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

@@ -7,46 +7,69 @@ module GraphQL
       module Resolve
         # Mutate `value`, replacing {Lazy} instances in place with their resolved values
         # @return [void]
+
+        # This object can be passed like an array, but it doesn't allocate an
+        # array until it's used.
+        #
+        # There's one crucial difference: you have to _capture_ the result
+        # of `#<<`. (This _works_ with arrays but isn't required, since it has a side-effect.)
+        # @api private
+        module NullAccumulator
+          def self.<<(item)
+            [item]
+          end
+
+          def self.empty?
+            true
+          end
+        end
+
         def self.resolve(value)
           lazies = resolve_in_place(value)
           deep_sync(lazies)
         end
 
         def self.resolve_in_place(value)
-          lazies = []
+          acc = each_lazy(NullAccumulator, value)
 
-          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)
+          if acc.empty?
+            Lazy::NullResult
+          else
+            acc.each_with_index do |field_result, idx|
+              acc[idx] = field_result.value.then do |inner_v|
+                field_result.value = inner_v
+                resolve_in_place(inner_v)
+              end
             end
-            lazies.push(inner_lazy)
-          end
 
-          Lazy.new { lazies.map(&:value) }
+            Lazy.new { acc.each_with_index { |l, idx| acc[idx] = l.value }; acc }
+          end
         end
 
-        # If `value` is a collection, call `block`
-        # with any {Lazy} instances in the collection
+        # If `value` is a collection,
+        # add any {Lazy} instances in the collection
+        # to `acc`
         # @return [void]
-        def self.each_lazy(value, &block)
+        def self.each_lazy(acc, value)
           case value
           when SelectionResult
             value.each do |key, field_result|
-              each_lazy(field_result, &block)
+              acc = each_lazy(acc, field_result)
             end
           when Array
             value.each do |field_result|
-              each_lazy(field_result, &block)
+              acc = each_lazy(acc, field_result)
             end
           when FieldResult
             field_value = value.value
             if field_value.is_a?(Lazy)
-              yield(value)
+              acc = acc << value
             else
-              each_lazy(field_value, &block)
+              acc = each_lazy(acc, field_value)
             end
           end
+
+          acc
         end
 
         # Traverse `val`, triggering resolution for each {Lazy}.

data/lib/graphql/execution/multiplex.rb

@@ -46,39 +46,25 @@ module GraphQL
         # @param max_complexity [Integer]
         # @return [Array<Hash>] One result per query
         def run_queries(schema, queries, context: {}, max_complexity: nil)
-          has_custom_strategy = schema.query_execution_strategy || schema.mutation_execution_strategy || schema.subscription_execution_strategy
-          if has_custom_strategy
-            if queries.length == 1
-              return [run_one_legacy(schema, queries.first)]
-            else
+          if has_custom_strategy?(schema)
+            if queries.length != 1
               raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
+            else
+              with_instrumentation(schema, queries, context: context, max_complexity: max_complexity) do
+                [run_one_legacy(schema, queries.first)]
+              end
             end
           else
-            run_as_multiplex(schema, queries, context: context, max_complexity: max_complexity)
+            with_instrumentation(schema, queries, context: context, max_complexity: max_complexity) do
+              run_as_multiplex(queries)
+            end
           end
         end
 
         private
 
-        def run_as_multiplex(schema, queries, context:, max_complexity:)
-          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
+        def run_as_multiplex(queries)
+          # Do as much eager evaluation of the query as possible
           results = queries.map do |query|
             begin_query(query)
           end
@@ -91,13 +77,6 @@ module GraphQL
             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
 
         # @param query [GraphQL::Query]
@@ -149,8 +128,6 @@ module GraphQL
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
-          instrumenters = schema.instrumenters[:query]
-          instrumenters.each { |i| i.before_query(query) }
           query.result = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors
             if all_errors.any?
@@ -161,8 +138,44 @@ module GraphQL
           else
             GraphQL::Query::Executor.new(query).result
           end
+        end
+
+        def has_custom_strategy?(schema)
+          schema.query_execution_strategy != GraphQL::Execution::Execute ||
+            schema.mutation_execution_strategy != GraphQL::Execution::Execute ||
+            schema.subscription_execution_strategy != GraphQL::Execution::Execute
+        end
+
+        # Apply multiplex & query instrumentation to `queries`.
+        #
+        # It yields when the queries should be executed, then runs teardown.
+        def with_instrumentation(schema, queries, context:, max_complexity:)
+          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)
+
+          # Let them be executed
+          yield
         ensure
-          instrumenters.reverse_each { |i| i.after_query(query) }
+          # 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
       end
     end

data/lib/graphql/field.rb

@@ -126,6 +126,7 @@ module GraphQL
       :type, :arguments,
       :property, :hash_key, :complexity,
       :mutation, :function,
+      :edge_class,
       :relay_node_field,
       :relay_nodes_field,
       argument: GraphQL::Define::AssignArgument
@@ -135,7 +136,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
+      :relay_node_field, :relay_nodes_field, :edges?, :edge_class
     )
 
     # @return [Boolean] True if this is the Relay find-by-id field
@@ -184,6 +185,15 @@ module GraphQL
       @connection
     end
 
+    # @return [nil, Class]
+    # @api private
+    attr_accessor :edge_class
+
+    # @return [Boolean]
+    def edges?
+      !!@edge_class
+    end
+
     # @return [nil, Integer]
     attr_accessor :connection_max_page_size
 

data/lib/graphql/internal_representation/node.rb

@@ -2,6 +2,8 @@
 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
 
@@ -15,7 +17,7 @@ module GraphQL
       # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>]
       def typed_children
         @typed_childen ||= begin
-          new_tc = Hash.new { |h, k| h[k] = {} }
+          new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
           if @scoped_children.any?
             all_object_types = Set.new
             scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }

data/lib/graphql/non_null_type.rb

@@ -30,7 +30,7 @@ module GraphQL
   #
   class NonNullType < GraphQL::BaseType
     include GraphQL::BaseType::ModifiesAnotherType
-    extend Forwardable
+    extend GraphQL::Delegate
 
     attr_reader :of_type
     def initialize(of_type:)

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 Forwardable
+    extend GraphQL::Delegate
 
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)

data/lib/graphql/query/arguments.rb

@@ -5,7 +5,7 @@ module GraphQL
     #
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
-      extend Forwardable
+      extend GraphQL::Delegate
 
       def initialize(values, argument_definitions:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
@@ -21,13 +21,15 @@ module GraphQL
       # @param key [String, Symbol] name or index of value to access
       # @return [Object] the argument at that key
       def [](key)
-        @argument_values.fetch(key.to_s, NULL_ARGUMENT_VALUE).value
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).value
       end
 
       # @param key [String, Symbol] name of value to access
       # @return [Boolean] true if the argument was present in this field
       def key?(key)
-        @argument_values.key?(key.to_s)
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.key?(key_s)
       end
 
       # Get the hash of all values, with stringified keys

data/lib/graphql/query/arguments_cache.rb

@@ -5,14 +5,18 @@ module GraphQL
       # @return [Hash<InternalRepresentation::Node, GraphQL::Language::NodesDirectiveNode => Hash<GraphQL::Field, GraphQL::Directive => GraphQL::Query::Arguments>>]
       def self.build(query)
         Hash.new do |h1, irep_or_ast_node|
-          Hash.new do |h2, definition|
+          h1[irep_or_ast_node] = Hash.new do |h2, definition|
             ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
             ast_arguments = ast_node.arguments
-            GraphQL::Query::LiteralInput.from_arguments(
-              ast_arguments,
-              definition.arguments,
-              query.variables,
-            )
+            h2[definition] = if definition.arguments.none?
+              GraphQL::Query::Arguments::NO_ARGS
+            else
+              GraphQL::Query::LiteralInput.from_arguments(
+                ast_arguments,
+                definition.arguments,
+                query.variables,
+              )
+            end
           end
         end
       end

data/lib/graphql/query/context.rb

@@ -4,7 +4,7 @@ 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
-      extend Forwardable
+      extend GraphQL::Delegate
       attr_reader :execution_strategy
       # `strategy` is required by GraphQL::Batch
       alias_method :strategy, :execution_strategy
@@ -73,7 +73,8 @@ module GraphQL
       def spawn(key:, selection:, parent_type:, field:)
         FieldResolutionContext.new(
           context: self,
-          path: path + [key],
+          parent: self,
+          key: key,
           selection: selection,
           parent_type: parent_type,
           field: field,
@@ -87,21 +88,29 @@ module GraphQL
       end
 
       class FieldResolutionContext
-        extend Forwardable
+        extend GraphQL::Delegate
 
-        attr_reader :path, :selection, :field, :parent_type
+        attr_reader :selection, :field, :parent_type, :query, :schema
 
-        def initialize(context:, path:, selection:, field:, parent_type:)
+        def initialize(context:, key:, selection:, parent:, field:, parent_type:)
           @context = context
-          @path = path
+          @key = key
+          @parent = parent
           @selection = selection
           @field = field
           @parent_type = parent_type
+          # This is needed constantly, so set it ahead of time:
+          @query = context.query
+          @schema = context.schema
+        end
+
+        def path
+          @path ||= @parent.path.dup << @key
         end
 
         def_delegators :@context,
           :[], :[]=, :key?, :fetch, :to_h, :namespace,
-          :spawn, :query, :schema, :warden, :errors,
+          :spawn, :schema, :warden, :errors,
           :execution_strategy, :strategy, :skip
 
         # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
@@ -131,7 +140,8 @@ module GraphQL
         def spawn(key:, selection:, parent_type:, field:)
           FieldResolutionContext.new(
             context: @context,
-            path: path + [key],
+            parent: self,
+            key: key,
             selection: selection,
             parent_type: parent_type,
             field: field,

data/lib/graphql/query/null_context.rb

@@ -16,7 +16,7 @@ module GraphQL
       end
 
       class << self
-        extend Forwardable
+        extend GraphQL::Delegate
 
         def instance
           @instance = self.new

data/lib/graphql/query/variables.rb

@@ -3,7 +3,7 @@ module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.
     class Variables
-      extend Forwardable
+      extend GraphQL::Delegate
 
       # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
       attr_reader :errors

data/lib/graphql/relay.rb

@@ -4,6 +4,7 @@ require 'base64'
 require 'graphql/relay/page_info'
 require 'graphql/relay/edge'
 require 'graphql/relay/edge_type'
+require 'graphql/relay/edges_instrumentation'
 require 'graphql/relay/base_connection'
 require 'graphql/relay/array_connection'
 require 'graphql/relay/range_add'

data/lib/graphql/relay/base_connection.rb

@@ -26,16 +26,14 @@ module GraphQL
         # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
         def connection_for_nodes(nodes)
           # Check for class _names_ because classes can be redefined in Rails development
-          ancestor_names = nodes.class.ancestors.map(&:name)
-          implementation_class_name = ancestor_names.find do |ancestor_class_name|
-            CONNECTION_IMPLEMENTATIONS.include? ancestor_class_name
-          end
-
-          if implementation_class_name.nil?
-            raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
-          else
-            CONNECTION_IMPLEMENTATIONS[implementation_class_name]
+          nodes.class.ancestors.each do |ancestor|
+            conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
+            if conn_impl
+              return conn_impl
+            end
           end
+          # Should have found a connection during the loop:
+          raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
         end
 
         # Add `connection_class` as the connection wrapper for `nodes_class`

data/lib/graphql/relay/connection_type.rb

@@ -9,9 +9,8 @@ module GraphQL
       self.default_nodes_field = false
 
       # Create a connection which exposes edges of this type
-      def self.create_type(wrapped_type, edge_type: nil, edge_class: nil, nodes_field: ConnectionType.default_nodes_field, &block)
-        edge_class ||= GraphQL::Relay::Edge
-        edge_type ||= wrapped_type.edge_type
+      def self.create_type(wrapped_type, edge_type: wrapped_type.edge_type, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
+        custom_edge_class = edge_class
 
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
@@ -19,20 +18,12 @@ module GraphQL
         ObjectType.define do
           name("#{wrapped_type.name}Connection")
           description("The connection type for #{wrapped_type.name}.")
-          field :edges, types[edge_type] do
-            description "A list of edges."
-            resolve ->(obj, args, ctx) {
-              obj.edge_nodes.map { |item| edge_class.new(item, obj) }
-            }
-          end
+          field :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :edge_nodes
+
           if nodes_field
-            field :nodes, types[wrapped_type] do
-              description "A list of nodes."
-              resolve ->(obj, args, ctx) {
-                obj.edge_nodes
-              }
-            end
+            field :nodes, types[wrapped_type],  "A list of nodes.", property: :edge_nodes
           end
+
           field :pageInfo, !PageInfo, "Information to aid in pagination.", property: :page_info
           block && instance_eval(&block)
         end

data/lib/graphql/relay/edges_instrumentation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    module EdgesInstrumentation
+      def self.instrument(type, field)
+        if field.edges?
+          edges_resolve = EdgesResolve.new(
+            edge_class: field.edge_class,
+            resolve: field.resolve_proc,
+            lazy_resolve: field.lazy_resolve_proc,
+          )
+
+          field.redefine(
+            resolve: edges_resolve.method(:resolve),
+            lazy_resolve: edges_resolve.method(:lazy_resolve),
+          )
+        else
+          field
+        end
+      end
+
+
+      class EdgesResolve
+        def initialize(edge_class:, resolve:, lazy_resolve:)
+          @edge_class = edge_class
+          @resolve_proc = resolve
+          @lazy_resolve_proc = lazy_resolve
+        end
+
+        # A user's custom Connection may return a lazy object,
+        # if so, handle it later.
+        def resolve(obj, args, ctx)
+          nodes = @resolve_proc.call(obj, args, ctx)
+          if ctx.schema.lazy?(nodes)
+            ConnectionResolve::LazyNodesWrapper.new(obj, nodes)
+          else
+            build_edges(nodes, obj)
+          end
+        end
+
+        # If we get this far, unwrap the wrapper,
+        # resolve the lazy object and make the edges as usual
+        def lazy_resolve(obj, args, ctx)
+          items = @lazy_resolve_proc.call(obj.lazy_object, args, ctx)
+          build_edges(items, obj.parent)
+        end
+
+        private
+
+        def build_edges(items, connection)
+          items.map { |item| @edge_class.new(item, connection) }
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema.rb

@@ -98,7 +98,7 @@ module GraphQL
       GraphQL::Filter.new(except: default_mask)
     end
 
-    self.default_execution_strategy = nil
+    self.default_execution_strategy = GraphQL::Execution::Execute
 
     BUILT_IN_TYPES = Hash[[INT_TYPE, STRING_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, ID_TYPE].map{ |type| [type.name, type] }]
     DIRECTIVES = [GraphQL::Directive::IncludeDirective, GraphQL::Directive::SkipDirective, GraphQL::Directive::DeprecatedDirective]
@@ -509,6 +509,7 @@ module GraphQL
     # @api private
     BUILT_IN_INSTRUMENTERS = [
       GraphQL::Relay::ConnectionInstrumentation,
+      GraphQL::Relay::EdgesInstrumentation,
       GraphQL::Relay::Mutation::Instrumentation,
     ]
 

data/lib/graphql/schema/middleware_chain.rb

@@ -5,7 +5,7 @@ module GraphQL
     #
     # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
     class MiddlewareChain
-      extend Forwardable
+      extend GraphQL::Delegate
 
       # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
       attr_reader :steps, :final_step
@@ -66,22 +66,13 @@ module GraphQL
       end
 
       def wrap(callable)
-        if get_arity(callable) == 6
+        if BackwardsCompatibility.get_arity(callable) == 6
           warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
           MiddlewareWrapper.new(callable)
         else
           callable
         end
       end
-
-      def get_arity(callable)
-        case callable
-        when Proc, Method
-          callable.arity
-        else
-          callable.method(:call).arity
-        end
-      end
     end
   end
 end

data/lib/graphql/schema/type_map.rb

@@ -8,7 +8,7 @@ module GraphQL
     #
     # If you want a type, but want to handle the undefined case, use {#fetch}.
     class TypeMap
-      extend Forwardable
+      extend GraphQL::Delegate
       def_delegators :@storage, :key?, :keys, :values, :to_h, :fetch, :each, :each_value
 
       def initialize

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -103,7 +103,7 @@ module GraphQL
       end
 
       class NodeWithPath
-        extend Forwardable
+        extend GraphQL::Delegate
         attr_reader :node, :path
         def initialize(node, path)
           @node = node

data/lib/graphql/static_validation/validation_context.rb

@@ -12,7 +12,7 @@ module GraphQL
     # It also provides limited access to the {TypeStack} instance,
     # which tracks state as you climb in and out of different fields.
     class ValidationContext
-      extend Forwardable
+      extend GraphQL::Delegate
 
       attr_reader :query, :schema,
         :document, :errors, :visitor,

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.6.2"
+  VERSION = "1.6.3"
 end

data/spec/graphql/execution/multiplex_spec.rb

@@ -64,6 +64,10 @@ describe GraphQL::Execution::Multiplex do
           nestedSum(value: 13) {
             value
           }
+          # This field will never get executed
+          ns2: nestedSum(value: 13) {
+            value
+          }
         }
       }
     }" }

data/spec/graphql/query_spec.rb

@@ -598,7 +598,12 @@ describe GraphQL::Query do
   end
 
   describe "query_execution_strategy" do
-    let(:custom_execution_schema) { schema.redefine(query_execution_strategy: DummyStrategy) }
+    let(:custom_execution_schema) {
+      schema.redefine do
+        query_execution_strategy DummyStrategy
+        instrument(:multiplex, DummyMultiplexInstrumenter)
+      end
+    }
 
     class DummyStrategy
       def execute(ast_operation, root_type, query_object)
@@ -606,9 +611,27 @@ describe GraphQL::Query do
       end
     end
 
+    class DummyMultiplexInstrumenter
+      def self.before_multiplex(m)
+        m.queries.first.context[:before_multiplex] = true
+      end
+
+      def self.after_multiplex(m)
+      end
+    end
+
     it "is used for running a query, if it's present and not the default" do
       result = custom_execution_schema.execute(" { __typename }")
       assert_equal({"data"=>{"dummy"=>true}}, result)
+
+      result = custom_execution_schema.execute(" mutation { __typename } ")
+      assert_equal({"data"=>{"__typename" => "Mutation"}}, result)
+    end
+
+    it "treats the query as a one-item multiplex" do
+      ctx = {}
+      custom_execution_schema.execute(" { __typename }", context: ctx)
+      assert_equal true, ctx[:before_multiplex]
     end
 
     it "can't run a multiplex" do

data/spec/support/dummy/data.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 require 'ostruct'
 module Dummy
-  Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source)
+  Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source) do
+    def ==(other)
+      # This is buggy on purpose -- it shouldn't be called during execution.
+      other.id == id
+    end
+  end
+
   CHEESES = {
     1 => Cheese.new(1, "Brie", "France", 0.19, 1),
     2 => Cheese.new(2, "Gouda", "Netherlands", 0.3, 1),

data/spec/support/star_wars/schema.rb

@@ -178,7 +178,11 @@ module StarWars
       }
     end
 
-    connection :basesWithCustomEdge, CustomEdgeBaseConnectionType, property: :bases
+    connection :basesWithCustomEdge, CustomEdgeBaseConnectionType do
+      resolve ->(o, a, c) {
+        LazyNodesWrapper.new(o.bases)
+      }
+    end
   end
 
   # Define a mutation. It will also:
@@ -271,6 +275,19 @@ module StarWars
     end
   end
 
+  LazyNodesWrapper = Struct.new(:relation)
+  class LazyNodesRelationConnection < GraphQL::Relay::RelationConnection
+    def initialize(wrapper, *args)
+      super(wrapper.relation, *args)
+    end
+
+    def edge_nodes
+      LazyWrapper.new { super }
+    end
+  end
+
+  GraphQL::Relay::BaseConnection.register_connection_implementation(LazyNodesWrapper, LazyNodesRelationConnection)
+
   QueryType = GraphQL::ObjectType.define do
     name "Query"
     field :rebels, Faction do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-02 00:00:00.000000000 Z
+date: 2017-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -445,6 +445,7 @@ files:
 - lib/graphql/relay/connection_type.rb
 - lib/graphql/relay/edge.rb
 - lib/graphql/relay/edge_type.rb
+- lib/graphql/relay/edges_instrumentation.rb
 - lib/graphql/relay/global_id_resolve.rb
 - lib/graphql/relay/mutation.rb
 - lib/graphql/relay/mutation/instrumentation.rb