graphql 1.5.15 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75e66219aaa22753f69fb7bef629535bd80e987e
-  data.tar.gz: dac5274307d3d472f739daf07c9daca74f010af4
+  metadata.gz: 21a090385055caa75ff227d787c3a794c5134c11
+  data.tar.gz: f6e6e5b3eb47827061ecc6327d2c431d57558be0
 SHA512:
-  metadata.gz: 5161c7c97fc9ffe14db133ad61099addfea4ccf94eba8bc0f2ff56e1e6cb541740018fed81644292915a76ccebd9640f2b22d7a81fb3a41d60c6a7a377b45a9a
-  data.tar.gz: 4ec7454191f5c7bf67aef5459bcfaeae1184c5968265a5f15b3e453827586b9a61d9783059aefcfc3df6285dec3ca7eb2445399123f9c9fee26012fb5a9621f2
+  metadata.gz: 9049055982560c7eebe4b37843ce665d885c32ed61f6b97dcb2cbfdefcade29cb62f98914f9824d4e772d410494c75abf732583c7ed2c6ebd87875a26897f7d9
+  data.tar.gz: ab419676204940e098b0bd2e612ce8cf6aa9b1456b03d599481be19a4a8e9efa4fed16238702e6d8a5a5df2dd4a6af472975400280729074f34c9e202612f0ef

data/lib/graphql.rb

@@ -3,26 +3,9 @@ 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
 
@@ -83,6 +66,7 @@ require "graphql/argument"
 require "graphql/field"
 require "graphql/type_kinds"
 
+require "graphql/backwards_compatibility"
 require "graphql/scalar_type"
 require "graphql/boolean_type"
 require "graphql/float_type"
@@ -95,6 +79,7 @@ require "graphql/introspection"
 require "graphql/language"
 require "graphql/analysis"
 require "graphql/execution"
+require "graphql/relay"
 require "graphql/schema"
 require "graphql/schema/loader"
 require "graphql/schema/printer"
@@ -108,6 +93,6 @@ require "graphql/query"
 require "graphql/internal_representation"
 require "graphql/static_validation"
 require "graphql/version"
-require "graphql/relay"
 require "graphql/compatibility"
 require "graphql/function"
+require "graphql/filter"

data/lib/graphql/analysis/analyze_query.rb

@@ -2,6 +2,27 @@
 module GraphQL
   module Analysis
     module_function
+
+    # @return [void]
+    def analyze_multiplex(multiplex, analyzers)
+      reducer_states = analyzers.map { |r| ReducerState.new(r, multiplex) }
+      query_results = multiplex.queries.map do |query|
+        if query.valid?
+          analyze_query(query, query.analyzers, multiplex_states: reducer_states)
+        else
+          []
+        end
+      end
+
+      multiplex_results = reducer_states.map(&:finalize_reducer)
+      multiplex_errors = analysis_errors(multiplex_results)
+
+      multiplex.queries.each_with_index do |query, idx|
+        query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
+      end
+      nil
+    end
+
     # Visit `query`'s internal representation, calling `analyzers` along the way.
     #
     # - First, query analyzers are initialized by calling `.initial_value(query)`, if they respond to that method.
@@ -13,8 +34,8 @@ module GraphQL
     # @param query [GraphQL::Query]
     # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
     # @return [Array<Any>] Results from those analyzers
-    def analyze_query(query, analyzers)
-      reducer_states = analyzers.map { |r| ReducerState.new(r, query) }
+    def analyze_query(query, analyzers, multiplex_states: [])
+      reducer_states = analyzers.map { |r| ReducerState.new(r, query) } + multiplex_states
 
       irep = query.internal_representation
 
@@ -49,5 +70,9 @@ module GraphQL
         reducer_state.memo = next_memo
       end
     end
+
+    def analysis_errors(results)
+      results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
+    end
   end
 end

data/lib/graphql/analysis/query_complexity.rb

@@ -4,7 +4,7 @@ module GraphQL
     # Calculate the complexity of a query, using {Field#complexity} values.
     #
     # @example Log the complexity of incoming queries
-    #   MySchema.query_analyzers << GraphQL::AnalysisQueryComplexity.new do |query, complexity|
+    #   MySchema.query_analyzers << GraphQL::Analysis::QueryComplexity.new do |query, complexity|
     #     Rails.logger.info("Complexity: #{complexity}")
     #   end
     #
@@ -17,11 +17,11 @@ module GraphQL
       end
 
       # State for the query complexity calcuation:
-      # - `query` is needed for variables, then passed to handler
+      # - `target` is passed to handler
       # - `complexities_on_type` holds complexity scores for each type in an IRep node
-      def initial_value(query)
+      def initial_value(target)
         {
-          query: query,
+          target: target,
           complexities_on_type: [TypeComplexity.new],
         }
       end
@@ -34,7 +34,7 @@ module GraphQL
           else
             type_complexities = memo[:complexities_on_type].pop
             child_complexity = type_complexities.max_possible_complexity
-            own_complexity = get_complexity(irep_node, memo[:query], child_complexity)
+            own_complexity = get_complexity(irep_node, child_complexity)
             memo[:complexities_on_type].last.merge(irep_node.owner_type, own_complexity)
           end
         end
@@ -44,21 +44,20 @@ module GraphQL
       # Send the query and complexity to the block
       # @return [Object, GraphQL::AnalysisError] Whatever the handler returns
       def final_value(reduced_value)
-        total_complexity = reduced_value[:complexities_on_type].pop.max_possible_complexity
-        @complexity_handler.call(reduced_value[:query], total_complexity)
+        total_complexity = reduced_value[:complexities_on_type].last.max_possible_complexity
+        @complexity_handler.call(reduced_value[:target], total_complexity)
       end
 
       private
 
       # Get a complexity value for a field,
       # by getting the number or calling its proc
-      def get_complexity(irep_node, query, child_complexity)
+      def get_complexity(irep_node, child_complexity)
         field_defn = irep_node.definition
         defined_complexity = field_defn.complexity
         case defined_complexity
         when Proc
-          args = query.arguments_for(irep_node, field_defn)
-          defined_complexity.call(query.context, args, child_complexity)
+          defined_complexity.call(irep_node.query.context, irep_node.arguments, child_complexity)
         when Numeric
           defined_complexity + (child_complexity || 0)
         else
@@ -70,7 +69,7 @@ module GraphQL
       # Find the maximum possible complexity among those combinations.
       class TypeComplexity
         def initialize
-          @types = Hash.new(0)
+          @types = Hash.new { |h, k| h[k] = 0 }
         end
 
         # Return the max possible complexity for types in this selection

data/lib/graphql/argument.rb

@@ -42,7 +42,7 @@ module GraphQL
 
     # @api private
     module DefaultPrepare
-      def self.call(value); value; end
+      def self.call(value, ctx); value; end
     end
 
     def initialize
@@ -81,16 +81,17 @@ module GraphQL
       @expose_as ||= (@as || @name).to_s
     end
 
-    # @param value
+    # @param value [Object] The incoming value from variables or query string literal
+    # @param ctx [GraphQL::Query::Context]
     # @return [Object] The prepared `value` for this argument or `value` itself if no `prepare` function exists.
-    def prepare(value)
-      @prepare_proc.call(value)
+    def prepare(value, ctx)
+      @prepare_proc.call(value, ctx)
     end
 
     # Assign a `prepare` function to prepare this argument's value before `resolve` functions are called.
-    # @param prepare_proc [Proc]
+    # @param prepare_proc [#<call(value, ctx)>]
     def prepare=(prepare_proc)
-      @prepare_proc = prepare_proc
+      @prepare_proc = BackwardsCompatibility.wrap_arity(prepare_proc, from: 1, to: 2, name: "Argument#prepare(value, ctx)")
     end
 
     NO_DEFAULT_VALUE = Object.new

data/lib/graphql/backwards_compatibility.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module GraphQL
+  # Helpers for migrating in a backwards-compatibile way
+  # @api private
+  module BackwardsCompatibility
+    module_function
+    # Given a callable whose API used to take `from` arguments,
+    # check its arity, and if needed, apply a wrapper so that
+    # it can be called with `to` arguments.
+    # If a wrapper is applied, warn the application with `name`.
+    def wrap_arity(callable, from:, to:, name:)
+      arity = get_arity(callable)
+      case arity
+      when to
+        # It already matches, return it as is
+        callable
+      when from
+        # It has the old arity, so wrap it with an arity converter
+        warn("#{name} with #{from} arguments is deprecated, it now accepts #{to} arguments")
+        ArityWrapper.new(callable, from)
+      else
+        raise "Can't wrap #{callable} (arity: #{arity}) to have arity #{to}"
+      end
+    end
+
+    def get_arity(callable)
+      case callable
+      when Proc
+        callable.arity
+      else
+        callable.method(:call).arity
+      end
+    end
+
+    class ArityWrapper
+      def initialize(callable, old_arity)
+        @callable = callable
+        @old_arity = old_arity
+      end
+
+      def call(*args)
+        backwards_compat_args = args.first(@old_arity)
+        @callable.call(*backwards_compat_args)
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/execution_specification.rb

@@ -15,6 +15,7 @@ module GraphQL
     # - Typecasting
     # - Error handling (raise / return GraphQL::ExecutionError)
     # - Provides Irep & AST node to resolve fn
+    # - Skipping fields
     #
     # Some things are explicitly _not_ tested here, because they're handled
     # by other parts of the system:
@@ -97,6 +98,19 @@ module GraphQL
             assert_equal ["SNCC"], res["data"]["node"]["organizations"].map { |o| o["name"] }
           end
 
+          def test_it_skips_skipped_fields
+            query_str = <<-GRAPHQL
+            {
+              o3001: organization(id: "3001")  { name }
+              o2001: organization(id: "2001")  { name }
+            }
+            GRAPHQL
+
+            res = execute_query(query_str)
+            assert_equal ["o2001"], res["data"].keys
+            assert_equal false, res.key?("errors")
+          end
+
           def test_it_propagates_nulls_to_field
             query_string = %|
             query getOrg($id: ID = "2001"){

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -158,7 +158,12 @@ module GraphQL
             field :organization, !organization_type do
               argument :id, !types.ID
               resolve ->(obj, args, ctx) {
-                args[:id].start_with?("2") && obj[args[:id]]
+                if args[:id].start_with?("2")
+                  obj[args[:id]]
+                else
+                  # test context.skip
+                  ctx.skip
+                end
               }
             end
 

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -180,6 +180,25 @@ module GraphQL
             ]
             assert_equal expected_log, log
           end
+
+          def test_it_skips_ctx_skip
+            query_string = <<-GRAPHQL
+            {
+              p0: push(value: 15) { value }
+              p1: push(value: 1) { value }
+              p2: push(value: 2) {
+                value
+                p3: push(value: 15) {
+                  value
+                }
+              }
+            }
+            GRAPHQL
+            pushes = []
+            res = self.class.lazy_schema.execute(query_string, context: {pushes: pushes})
+            assert_equal [[1,2]], pushes
+            assert_equal({"data"=>{"p1"=>{"value"=>1}, "p2"=>{"value"=>2}}}, res)
+          end
         end
       end
     end

data/lib/graphql/compatibility/lazy_execution_specification/lazy_schema.rb

@@ -10,21 +10,30 @@ module GraphQL
               @value = nil
             elsif value == 14
               @value = GraphQL::ExecutionError.new("oops!")
+            elsif value == 15
+              @skipped = true
+              @value = ctx.skip
             else
               @value = value
             end
             @context = ctx
             pushes = @context[:lazy_pushes] ||= []
-            pushes << @value
+            if !@skipped
+              pushes << @value
+            end
           end
 
           def push
-            if @context[:lazy_pushes].include?(@value)
-              @context[:lazy_instrumentation] && @context[:lazy_instrumentation] << "PUSH"
-              @context[:pushes] << @context[:lazy_pushes]
-              @context[:lazy_pushes] = []
+            if @skipped
+              @value
+            else
+              if @context[:lazy_pushes].include?(@value)
+                @context[:lazy_instrumentation] && @context[:lazy_instrumentation] << "PUSH"
+                @context[:pushes] << @context[:lazy_pushes]
+                @context[:lazy_pushes] = []
+              end
+              self
             end
-            self
           end
         end
 

data/lib/graphql/directive.rb

@@ -13,7 +13,7 @@ module GraphQL
     attr_accessor :locations, :arguments, :name, :description
     # @api private
     attr_writer :default_directive
-    ensure_defined(:locations, :arguments, :name, :description, :default_directive?, :default_arguments)
+    ensure_defined(:locations, :arguments, :name, :description, :default_directive?)
 
     LOCATIONS = [
       QUERY =                  :QUERY,
@@ -83,11 +83,6 @@ module GraphQL
     def default_directive?
       @default_directive
     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
   end
 end
 

data/lib/graphql/execution.rb

@@ -3,5 +3,6 @@ require "graphql/execution/directive_checks"
 require "graphql/execution/execute"
 require "graphql/execution/field_result"
 require "graphql/execution/lazy"
+require "graphql/execution/multiplex"
 require "graphql/execution/selection_result"
 require "graphql/execution/typecast"

data/lib/graphql/execution/execute.rb

@@ -4,7 +4,10 @@ module GraphQL
     # A valid execution strategy
     # @api private
     class Execute
-      PROPAGATE_NULL = :__graphql_propagate_null__
+      # @api private
+      SKIP = Object.new
+      # @api private
+      PROPAGATE_NULL = Object.new
 
       def execute(ast_operation, root_type, query)
         result = resolve_selection(
@@ -20,200 +23,211 @@ module GraphQL
         result.to_h
       end
 
-      private
-
-      def resolve_selection(object, current_type, selection, query_ctx, mutation: false )
-        selection_result = SelectionResult.new
+      # @api private
+      module ExecutionFunctions
+        module_function
+
+        def resolve_selection(object, current_type, selection, query_ctx, mutation: false )
+          selection_result = SelectionResult.new
+
+          selection.typed_children[current_type].each do |name, subselection|
+            field_result = resolve_field(
+              selection_result,
+              subselection,
+              current_type,
+              subselection.definition,
+              object,
+              query_ctx
+            )
 
-        selection.typed_children[current_type].each do |name, subselection|
-          field_result = resolve_field(
-            selection_result,
-            subselection,
-            current_type,
-            subselection.definition,
-            object,
-            query_ctx
-          )
+            if field_result == SKIP
+              next
+            end
 
-          if mutation
-            GraphQL::Execution::Lazy.resolve(field_result)
-          end
+            if mutation
+              GraphQL::Execution::Lazy.resolve(field_result)
+            end
 
-          selection_result.set(name, field_result)
+            selection_result.set(name, field_result)
 
-          # If the last subselection caused a null to propagate to _this_ selection,
-          # then we may as well quit executing fields because they
-          # won't be in the response
-          if selection_result.invalid_null?
-            break
+            # If the last subselection caused a null to propagate to _this_ selection,
+            # then we may as well quit executing fields because they
+            # won't be in the response
+            if selection_result.invalid_null?
+              break
+            end
           end
-        end
-
-        selection_result
-      end
 
-      def resolve_field(owner, selection, parent_type, field, object, query_ctx)
-        query = query_ctx.query
-        field_ctx = query_ctx.spawn(
-          parent_type: parent_type,
-          field: field,
-          key: selection.name,
-          selection: selection,
-        )
-
-        arguments = query.arguments_for(selection, field)
-        raw_value = begin
-          query_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
-        rescue GraphQL::ExecutionError => err
-          err
+          selection_result
         end
 
-        result = if query.schema.lazy?(raw_value)
-          field.prepare_lazy(raw_value, arguments, field_ctx).then { |inner_value|
-            continue_resolve_field(owner, selection, parent_type, field, inner_value, field_ctx)
-          }
-        elsif raw_value.is_a?(GraphQL::Execution::Lazy)
-          # It came from a connection resolve, assume it was already instrumented
-          raw_value.then { |inner_value|
-            continue_resolve_field(owner, selection, parent_type, field, inner_value, field_ctx)
-          }
-        else
-          continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
-        end
-
-        case result
-        when PROPAGATE_NULL, GraphQL::Execution::Lazy, SelectionResult
-          FieldResult.new(
-            owner: owner,
-            type: field.type,
-            value: result,
+        def resolve_field(owner, selection, parent_type, field, object, query_ctx)
+          query = query_ctx.query
+          field_ctx = query_ctx.spawn(
+            parent_type: parent_type,
+            field: field,
+            key: selection.name,
+            selection: selection,
           )
-        else
-          result
-        end
-      end
 
-      def continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
-        query = field_ctx.query
-
-        case raw_value
-        when GraphQL::ExecutionError
-          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 = field_ctx.ast_node
-              error.path = field_ctx.path + [index]
-              query.context.errors.push(error)
-            end
+          arguments = query.arguments_for(selection, field)
+          raw_value = begin
+            query_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
+          rescue GraphQL::ExecutionError => err
+            err
           end
-        end
-
-        resolve_value(
-          owner,
-          parent_type,
-          field,
-          field.type,
-          raw_value,
-          selection,
-          field_ctx,
-        )
-      end
 
-      def resolve_value(owner, parent_type, field_defn, field_type, value, selection, field_ctx)
-        if value.nil?
-          if field_type.kind.non_null?
-            type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
-            field_ctx.schema.type_error(type_error, field_ctx)
-            PROPAGATE_NULL
+          result = if query.schema.lazy?(raw_value)
+            field.prepare_lazy(raw_value, arguments, field_ctx).then { |inner_value|
+              continue_resolve_field(owner, selection, parent_type, field, inner_value, field_ctx)
+            }
+          elsif raw_value.is_a?(GraphQL::Execution::Lazy)
+            # It came from a connection resolve, assume it was already instrumented
+            raw_value.then { |inner_value|
+              continue_resolve_field(owner, selection, parent_type, field, inner_value, field_ctx)
+            }
           else
-            nil
+            continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
           end
-        elsif value.is_a?(GraphQL::ExecutionError)
-          if field_type.kind.non_null?
-            PROPAGATE_NULL
+
+          case result
+          when PROPAGATE_NULL, GraphQL::Execution::Lazy, SelectionResult
+            FieldResult.new(
+              owner: owner,
+              type: field.type,
+              value: result,
+            )
           else
-            nil
+            result
           end
-        else
-          case field_type.kind
-          when GraphQL::TypeKinds::SCALAR
-            field_type.coerce_result(value, field_ctx)
-          when GraphQL::TypeKinds::ENUM
-            field_type.coerce_result(value, field_ctx)
-          when GraphQL::TypeKinds::LIST
-            inner_type = field_type.of_type
-            i = 0
-            result = []
-            value.each do |inner_value|
-              inner_ctx = field_ctx.spawn(
-                key: i,
-                selection: selection,
-                parent_type: parent_type,
-                field: field_defn,
-              )
-
-              inner_result = resolve_value(
-                owner,
-                parent_type,
-                field_defn,
-                inner_type,
-                inner_value,
-                selection,
-                inner_ctx,
-              )
+        end
 
-              result << GraphQL::Execution::FieldResult.new(type: inner_type, owner: owner, value: inner_result)
-              i += 1
+        def continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
+          query = field_ctx.query
+
+          case raw_value
+          when GraphQL::ExecutionError
+            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 = field_ctx.ast_node
+                error.path = field_ctx.path + [index]
+                query.context.errors.push(error)
+              end
             end
-            result
-          when GraphQL::TypeKinds::NON_NULL
-            wrapped_type = field_type.of_type
-            resolve_value(
-              owner,
-              parent_type,
-              field_defn,
-              wrapped_type,
-              value,
-              selection,
-              field_ctx,
-            )
-          when GraphQL::TypeKinds::OBJECT
-            resolve_selection(
-              value,
-              field_type,
-              selection,
-              field_ctx
-            )
-          when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
-            query = field_ctx.query
-            resolved_type = query.resolve_type(value)
-            possible_types = query.possible_types(field_type)
+          end
 
-            if !possible_types.include?(resolved_type)
-              type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+          resolve_value(
+            owner,
+            parent_type,
+            field,
+            field.type,
+            raw_value,
+            selection,
+            field_ctx,
+          )
+        end
+
+        def resolve_value(owner, parent_type, field_defn, field_type, value, selection, field_ctx)
+          if value.nil?
+            if field_type.kind.non_null?
+              type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
               field_ctx.schema.type_error(type_error, field_ctx)
               PROPAGATE_NULL
             else
+              nil
+            end
+          elsif value.is_a?(GraphQL::ExecutionError)
+            if field_type.kind.non_null?
+              PROPAGATE_NULL
+            else
+              nil
+            end
+          elsif value == SKIP
+            value
+          else
+            case field_type.kind
+            when GraphQL::TypeKinds::SCALAR
+              field_type.coerce_result(value, field_ctx)
+            when GraphQL::TypeKinds::ENUM
+              field_type.coerce_result(value, field_ctx)
+            when GraphQL::TypeKinds::LIST
+              inner_type = field_type.of_type
+              i = 0
+              result = []
+              value.each do |inner_value|
+                inner_ctx = field_ctx.spawn(
+                  key: i,
+                  selection: selection,
+                  parent_type: parent_type,
+                  field: field_defn,
+                )
+
+                inner_result = resolve_value(
+                  owner,
+                  parent_type,
+                  field_defn,
+                  inner_type,
+                  inner_value,
+                  selection,
+                  inner_ctx,
+                )
+
+                result << GraphQL::Execution::FieldResult.new(type: inner_type, owner: owner, value: inner_result)
+                i += 1
+              end
+              result
+            when GraphQL::TypeKinds::NON_NULL
+              wrapped_type = field_type.of_type
               resolve_value(
                 owner,
                 parent_type,
                 field_defn,
-                resolved_type,
+                wrapped_type,
                 value,
                 selection,
                 field_ctx,
               )
+            when GraphQL::TypeKinds::OBJECT
+              resolve_selection(
+                value,
+                field_type,
+                selection,
+                field_ctx
+              )
+            when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
+              query = field_ctx.query
+              resolved_type = query.resolve_type(value)
+              possible_types = query.possible_types(field_type)
+
+              if !possible_types.include?(resolved_type)
+                type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+                field_ctx.schema.type_error(type_error, field_ctx)
+                PROPAGATE_NULL
+              else
+                resolve_value(
+                  owner,
+                  parent_type,
+                  field_defn,
+                  resolved_type,
+                  value,
+                  selection,
+                  field_ctx,
+                )
+              end
+            else
+              raise("Unknown type kind: #{field_type.kind}")
             end
-          else
-            raise("Unknown type kind: #{field_type.kind}")
           end
         end
       end
 
+      include ExecutionFunctions
+
       # A `.call`-able suitable to be the last step in a middleware chain
       module FieldResolveStep
         # Execute the field's resolve method