graphql 1.13.6 → 2.0.0

data/lib/generators/graphql/type_generator.rb

@@ -8,13 +8,28 @@ require_relative 'core'
 
 module Graphql
   module Generators
-    class TypeGeneratorBase < Rails::Generators::Base
+    class TypeGeneratorBase < Rails::Generators::NamedBase
       include Core
 
-      argument :type_name,
-        type: :string,
-        banner: "TypeName",
-        desc: "Name of this object type (expressed as Ruby or GraphQL)"
+      class_option 'namespaced_types',
+        type: :boolean,
+        required: false,
+        default: false,
+        banner: "Namespaced",
+        desc: "If the generated types will be namespaced"
+
+      argument :custom_fields,
+                type: :array,
+                default: [],
+                banner: "name:type name:type ...",
+                desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+
+      
+      attr_accessor :graphql_type
+
+      def create_type_file
+        template "#{graphql_type}.erb", "#{options[:directory]}/types#{subdirectory}/#{type_file_name}.rb"
+      end
 
       # Take a type expression in any combination of GraphQL or Ruby styles
       # and return it in a specified output style
@@ -60,12 +75,12 @@ module Graphql
 
       # @return [String] The user-provided type name, normalized to Ruby code
       def type_ruby_name
-        @type_ruby_name ||= self.class.normalize_type_expression(type_name, mode: :ruby)[0]
+        @type_ruby_name ||= self.class.normalize_type_expression(name, mode: :ruby)[0]
       end
 
       # @return [String] The user-provided type name, as a GraphQL name
       def type_graphql_name
-        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
+        @type_graphql_name ||= self.class.normalize_type_expression(name, mode: :graphql)[0]
       end
 
       # @return [String] The user-provided type name, as a file name (without extension)
@@ -82,6 +97,24 @@ module Graphql
         }
       end
 
+      def ruby_class_name
+        class_prefix = 
+          if options[:namespaced_types]
+            "#{graphql_type.pluralize.camelize}::"
+          else
+            ""
+          end
+        @ruby_class_name || class_prefix + type_ruby_name.sub(/^Types::/, "")
+      end
+
+      def subdirectory
+        if options[:namespaced_types]
+          "/#{graphql_type.pluralize}"
+        else
+          ""
+        end
+      end
+
       class NormalizedField
         def initialize(name, type_expr, null)
           @name = name
@@ -89,8 +122,12 @@ module Graphql
           @null = null
         end
 
-        def to_ruby
-          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        def to_object_field
+          "field :#{@name}, #{@type_expr}#{@null ? '' : ', null: false'}"
+        end
+
+        def to_input_argument
+          "argument :#{@name}, #{@type_expr}, required: false"
         end
       end
     end

data/lib/generators/graphql/union_generator.rb

@@ -19,14 +19,14 @@ module Graphql
         banner: "type type ...",
         desc: "Possible types for this union (expressed as Ruby or GraphQL)"
 
-      def create_type_file
-        template "union.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
-      end
-
       private
 
+      def graphql_type
+        "union"
+      end
+
       def normalized_possible_types
-        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
+        custom_fields.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
       end
     end
   end

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -5,7 +5,7 @@ module GraphQL
     module AST
       class QueryComplexity < Analyzer
         # State for the query complexity calculation:
-        # - `complexities_on_type` holds complexity scores for each type in an IRep node
+        # - `complexities_on_type` holds complexity scores for each type
         def initialize(query)
           super
           @complexities_on_type_by_query = {}

data/lib/graphql/analysis/ast/query_depth.rb

@@ -15,7 +15,6 @@ module GraphQL
     #   # In your Schema file:
     #
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Analysis::AST
     #     query_analyzer LogQueryDepth
     #   end
     #

data/lib/graphql/analysis/ast/visitor.rb

@@ -43,7 +43,7 @@ module GraphQL
 
         # Visit Helpers
 
-        # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
+        # @return [GraphQL::Execution::Interpreter::Arguments] Arguments for this node, merging default values, literal values and query variables
         # @see {GraphQL::Query#arguments_for}
         def arguments_for(ast_node, field_definition)
           @query.arguments_for(ast_node, field_definition)
@@ -100,7 +100,8 @@ module GraphQL
         def on_field(node, parent)
           @response_path.push(node.alias || node.name)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name, @query.context)
+          # This could be nil if the previous field wasn't found:
+          field_definition = parent_type && @schema.get_field(parent_type, node.name, @query.context)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap

data/lib/graphql/analysis/ast.rb

@@ -11,16 +11,6 @@ module GraphQL
   module Analysis
     module AST
       module_function
-
-      def use(schema_class)
-        if schema_class.analysis_engine == self
-          definition_line = caller(2, 1).first
-          GraphQL::Deprecation.warn("GraphQL::Analysis::AST is now the default; remove `use GraphQL::Analysis::AST` from the schema definition (#{definition_line})")
-        else
-          schema_class.analysis_engine = self
-        end
-      end
-
       # Analyze a multiplex, and all queries within.
       # Multiplex analyzers are ran for all queries, keeping state.
       # Query analyzers are ran per query, without carrying state between queries.

data/lib/graphql/analysis.rb

@@ -1,9 +1,2 @@
 # frozen_string_literal: true
 require "graphql/analysis/ast"
-require "graphql/analysis/max_query_complexity"
-require "graphql/analysis/max_query_depth"
-require "graphql/analysis/query_complexity"
-require "graphql/analysis/query_depth"
-require "graphql/analysis/reducer_state"
-require "graphql/analysis/analyze_query"
-require "graphql/analysis/field_usage"

data/lib/graphql/backtrace/table.rb

@@ -97,24 +97,6 @@ module GraphQL
           else
             rows
           end
-        when GraphQL::Query::Context::FieldResolutionContext
-          ctx = context_entry
-          field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
-          position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
-          field_alias = ctx.ast_node.alias
-          object = ctx.object
-          if object.is_a?(GraphQL::Schema::Object)
-            object = object.object
-          end
-          rows << [
-            "#{position}",
-            "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{object.inspect}",
-            ctx.irep_node.arguments.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
-          ]
-
-          build_rows(ctx.parent, rows: rows)
         when GraphQL::Query::Context
           query = context_entry.query
           op = query.selected_operation

data/lib/graphql/backtrace/tracer.rb

@@ -23,7 +23,7 @@ module GraphQL
             push_data = multiplex.queries.first
           end
         when "execute_field", "execute_field_lazy"
-          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          query = metadata[:query]
           multiplex = query.multiplex
           push_key = metadata[:path]
           parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
@@ -62,7 +62,6 @@ module GraphQL
             potential_context = multiplex_context[:last_graphql_backtrace_context]
 
             if potential_context.is_a?(GraphQL::Query::Context) ||
-                potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext) ||
                 potential_context.is_a?(Backtrace::Frame)
               raise TracedError.new(err, potential_context)
             else

data/lib/graphql/backtrace.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require "graphql/backtrace/inspect_result"
-require "graphql/backtrace/legacy_tracer"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
 require "graphql/backtrace/tracer"
@@ -23,13 +22,8 @@ module GraphQL
 
     def_delegators :to_a, :each, :[]
 
-    def self.use(schema_defn, legacy: false)
-      tracer = if legacy
-        self::LegacyTracer
-      else
-        self::Tracer
-      end
-      schema_defn.tracer(tracer)
+    def self.use(schema_defn)
+      schema_defn.tracer(self::Tracer)
     end
 
     def initialize(context, value: nil)

data/lib/graphql/dataloader/source.rb

@@ -138,8 +138,8 @@ module GraphQL
       # @api private
       def result_for(key)
         if !@results.key?(key)
-          raise <<-ERR
-Invariant: fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
+          raise GraphQL::InvariantError, <<-ERR
+Fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
 
 This key should have been loaded already. This is a bug in GraphQL::Dataloader, please report it on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new.
 ERR

data/lib/graphql/dig.rb

@@ -2,7 +2,7 @@
 module GraphQL
   module Dig
     # implemented using the old activesupport #dig instead of the ruby built-in
-    # so we can use some of the magic in Schema::InputObject and Query::Arguments
+    # so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
     # to handle stringified/symbolized keys.
     #
     # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly

data/lib/graphql/execution/errors.rb

@@ -2,14 +2,11 @@
 
 module GraphQL
   module Execution
-    # A plugin that wraps query execution with error handling.
-    # Supports class-based schemas and the new {Interpreter} runtime only.
+    # A plugin that wraps query execution with error handling. Installed by default.
     #
     # @example Handling ActiveRecord::NotFound
     #
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Execution::Errors
-    #
     #     rescue_from(ActiveRecord::NotFound) do |err, obj, args, ctx, field|
     #       ErrorTracker.log("Not Found: #{err.message}")
     #       nil
@@ -17,11 +14,6 @@ module GraphQL
     #   end
     #
     class Errors
-      def self.use(schema)
-        definition_line = caller(2, 1).first
-        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
-      end
-
       NEW_HANDLER_HASH = ->(h, k) {
         h[k] = {
           class: k,

data/lib/graphql/execution/interpreter/runtime.rb

@@ -472,10 +472,6 @@ module GraphQL
                   # Use this flag to tell Interpreter::Arguments to add itself
                   # to the keyword args hash _before_ freezing everything.
                   extra_args[:argument_details] = :__arguments_add_self
-                when :irep_node
-                  # This is used by `__typename` in order to support the legacy runtime,
-                  # but it has no use here (and it's always `nil`).
-                  # Stop adding it here to avoid the overhead of `.merge_extras` below.
                 when :parent
                   extra_args[:parent] = parent_object
                 else
@@ -619,7 +615,7 @@ module GraphQL
                 err
               end
               continue_value(path, next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
-            elsif GraphQL::Execution::Execute::SKIP == value
+            elsif GraphQL::Execution::SKIP == value
               # It's possible a lazy was already written here
               case selection_result
               when GraphQLResultHash
@@ -819,9 +815,6 @@ module GraphQL
             yield
           else
             dir_defn = @schema_directives.fetch(dir_node.name)
-            if !dir_defn.is_a?(Class)
-              dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
-            end
             raw_dir_args = arguments(nil, dir_defn, dir_node)
             dir_args = continue_value(
               @context[:current_path], # path
@@ -847,7 +840,7 @@ module GraphQL
         # Check {Schema::Directive.include?} for each directive that's present
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
-            dir_defn = @schema_directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
+            dir_defn = @schema_directives.fetch(dir_node.name)
             args = arguments(graphql_object, dir_defn, dir_node)
             if !dir_defn.include?(graphql_object, args, context)
               return false

data/lib/graphql/execution/interpreter.rb

@@ -11,28 +11,6 @@ require "graphql/execution/interpreter/handles_raw_value"
 module GraphQL
   module Execution
     class Interpreter
-      def initialize
-      end
-
-      # Support `Executor` :S
-      def execute(_operation, _root_type, query)
-        runtime = evaluate(query)
-        sync_lazies(query: query)
-        runtime.final_result
-      end
-
-      def self.use(schema_class)
-        if schema_class.interpreter?
-          definition_line = caller(2, 1).first
-          GraphQL::Deprecation.warn("GraphQL::Execution::Interpreter is now the default; remove `use GraphQL::Execution::Interpreter` from the schema definition (#{definition_line})")
-        else
-          schema_class.query_execution_strategy(self)
-          schema_class.mutation_execution_strategy(self)
-          schema_class.subscription_execution_strategy(self)
-          schema_class.add_subscription_extension_if_necessary
-        end
-      end
-
       def self.begin_multiplex(multiplex)
         # Since this is basically the batching context,
         # share it for a whole multiplex

data/lib/graphql/execution/lazy.rb

@@ -52,7 +52,7 @@ module GraphQL
         # (fewer clauses in a hot `case` block), but now it requires special handling here.
         # I think it's still worth it for the performance win, but if the number of special
         # cases grows, then maybe it's worth rethinking somehow.
-        if @value.is_a?(StandardError) && @value != GraphQL::Execution::Execute::SKIP
+        if @value.is_a?(StandardError) && @value != GraphQL::Execution::SKIP
           raise @value
         else
           @value

data/lib/graphql/execution/lookahead.rb

@@ -91,7 +91,7 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_name = normalize_name(field_name)
 
-        next_field_defn = get_class_based_field(selected_type, next_field_name)
+        next_field_defn = @query.get_field(selected_type, next_field_name)
         if next_field_defn
           next_nodes = []
           @ast_nodes.each do |ast_node|
@@ -137,7 +137,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = get_class_based_field(type, ast_nodes.first.name)
+            field_defn = @query.get_field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -213,17 +213,10 @@ module GraphQL
         end
       end
 
-      # Wrap get_field and ensure that it returns a GraphQL::Schema::Field.
-      # Remove this when legacy execution is removed.
-      def get_class_based_field(type, name)
-        f = @query.get_field(type, name)
-        f && f.type_class
-      end
-
       def skipped_by_directive?(ast_selection)
         ast_selection.directives.each do |directive|
           dir_defn = @query.schema.directives.fetch(directive.name)
-          directive_class = dir_defn.type_class
+          directive_class = dir_defn
           if directive_class
             dir_args = @query.arguments_for(directive, dir_defn)
             return true unless directive_class.static_include?(dir_args, @query.context)
@@ -244,7 +237,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = get_class_based_field(selected_type, ast_selection.name)
+              field_defn = @query.get_field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -254,14 +247,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.get_type(t.name).type_class
+              on_type = @query.get_type(t.name)
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
             # Again, assuming a valid AST
-            on_type = @query.get_type(frag_defn.type.name).type_class
+            on_type = @query.get_type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else

data/lib/graphql/execution/multiplex.rb

@@ -45,30 +45,64 @@ module GraphQL
       end
 
       class << self
-        def run_all(schema, query_options, **kwargs)
-          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, **opts) }
-          run_queries(schema, queries, **kwargs)
-        end
-
         # @param schema [GraphQL::Schema]
-        # @param queries [Array<GraphQL::Query>]
+        # @param queries [Array<GraphQL::Query, Hash>]
         # @param context [Hash]
         # @param max_complexity [Integer, nil]
         # @return [Array<Hash>] One result per query
-        def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
+        def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+          queries = query_options.map do |opts|
+            case opts
+            when Hash
+              GraphQL::Query.new(schema, nil, **opts)
+            when GraphQL::Query
+              opts
+            else
+              raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+            end
+          end
+
           multiplex = self.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
           multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
-            if supports_multiplexing?(schema)
-              instrument_and_analyze(multiplex) do
-                run_as_multiplex(multiplex)
+            GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
+              schema = multiplex.schema
+              multiplex_analyzers = schema.multiplex_analyzers
+              if multiplex.max_complexity
+                multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
               end
-            else
-              if queries.length != 1
-                raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
-              else
-                instrument_and_analyze(multiplex) do
-                  [run_one_legacy(schema, queries.first)]
+
+              schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+
+              begin
+                multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
+                # Do as much eager evaluation of the query as possible
+                results = []
+                queries.each_with_index do |query, idx|
+                  multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
                 end
+
+                multiplex.dataloader.run
+
+                # Then, work through lazy results in a breadth-first way
+                multiplex.dataloader.append_job {
+                  multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+                }
+                multiplex.dataloader.run
+
+                # Then, find all errors and assign the result to the query object
+                results.each_with_index do |data_result, idx|
+                  query = queries[idx]
+                  finish_query(data_result, query, multiplex)
+                  # Get the Query::Result, not the Hash
+                  results[idx] = query.result
+                end
+
+                results
+              rescue Exception
+                # TODO rescue at a higher level so it will catch errors in analysis, too
+                # Assign values here so that the query's `@executed` becomes true
+                queries.map { |q| q.result_values ||= {} }
+                raise
               end
             end
           end
@@ -81,7 +115,6 @@ module GraphQL
             NO_OPERATION
           else
             begin
-              # These were checked to be the same in `#supports_multiplexing?`
               query.schema.query_execution_strategy.begin_query(query, multiplex)
             rescue GraphQL::ExecutionError => err
               query.context.errors << err
@@ -94,40 +127,6 @@ module GraphQL
 
         private
 
-        def run_as_multiplex(multiplex)
-
-          multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
-          queries = multiplex.queries
-          # Do as much eager evaluation of the query as possible
-          results = []
-          queries.each_with_index do |query, idx|
-            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
-          end
-
-          multiplex.dataloader.run
-
-          # Then, work through lazy results in a breadth-first way
-          multiplex.dataloader.append_job {
-            multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
-          }
-          multiplex.dataloader.run
-
-          # Then, find all errors and assign the result to the query object
-          results.each_with_index do |data_result, idx|
-            query = queries[idx]
-            finish_query(data_result, query, multiplex)
-            # Get the Query::Result, not the Hash
-            results[idx] = query.result
-          end
-
-          results
-        rescue Exception
-          # TODO rescue at a higher level so it will catch errors in analysis, too
-          # Assign values here so that the query's `@executed` becomes true
-          queries.map { |q| q.result_values ||= {} }
-          raise
-        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
@@ -155,62 +154,6 @@ module GraphQL
             query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
           end
         end
-
-        # use the old `query_execution_strategy` etc to run this query
-        def run_one_legacy(schema, query)
-          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
-
-          query.result_values = if !query.valid?
-            all_errors = query.validation_errors + query.analysis_errors + query.context.errors
-            if all_errors.any?
-              { "errors" => all_errors.map(&:to_h) }
-            else
-              nil
-            end
-          else
-            GraphQL::Query::Executor.new(query).result
-          end
-        end
-
-        DEFAULT_STRATEGIES = [
-          GraphQL::Execution::Execute,
-          GraphQL::Execution::Interpreter
-        ]
-        # @return [Boolean] True if the schema is only using one strategy, and it's one that supports multiplexing.
-        def supports_multiplexing?(schema)
-          schema_strategies = [schema.query_execution_strategy, schema.mutation_execution_strategy, schema.subscription_execution_strategy]
-          schema_strategies.uniq!
-          schema_strategies.size == 1 && DEFAULT_STRATEGIES.include?(schema_strategies.first)
-        end
-
-        # Apply multiplex & query instrumentation to `queries`.
-        #
-        # It yields when the queries should be executed, then runs teardown.
-        def instrument_and_analyze(multiplex)
-          GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
-            schema = multiplex.schema
-            if schema.interpreter? && schema.analysis_engine != GraphQL::Analysis::AST
-              raise <<-ERR
-Can't use `GraphQL::Execution::Interpreter` without `GraphQL::Analysis::AST`, please add this plugin to your schema:
-
-    use GraphQL::Analysis::AST
-
-For information about the new analysis engine: https://graphql-ruby.org/queries/ast_analysis.html
-ERR
-            end
-            multiplex_analyzers = schema.multiplex_analyzers
-            if multiplex.max_complexity
-              multiplex_analyzers += if schema.using_ast_analysis?
-                [GraphQL::Analysis::AST::MaxQueryComplexity]
-              else
-                [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
-              end
-            end
-
-            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-            yield
-          end
-        end
       end
     end
   end

data/lib/graphql/execution.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 require "graphql/execution/directive_checks"
-require "graphql/execution/execute"
-require "graphql/execution/flatten"
 require "graphql/execution/instrumentation"
 require "graphql/execution/interpreter"
 require "graphql/execution/lazy"
 require "graphql/execution/lookahead"
 require "graphql/execution/multiplex"
-require "graphql/execution/typecast"
 require "graphql/execution/errors"
+
+module GraphQL
+  module Execution
+    # @api private
+    class Skip < GraphQL::Error; end
+
+    # Just a singleton for implementing {Query::Context#skip}
+    # @api private
+    SKIP = Skip.new
+  end
+end