graphql 1.13.14 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '032739327be4e27b1c7d2dbc3d24a5db771a713ec683238da1e9cd850993ff73'
-  data.tar.gz: b8c12e62126d761283086ccda4095812db080611b463bb0770603ea85c965c02
+  metadata.gz: c54b2619d5d111575839ba3e5d34794d993cb37a0b9aee4d41347551bb6be846
+  data.tar.gz: f6d53678c268767478a2a86ec34c045ab8744f4ea6f97deeebed3708df634340
 SHA512:
-  metadata.gz: c1a66366e1cceae9717bf8a4dc902cf9a670cee49e5017d45d7b9375149f579fa54f31ed0d47b73f71552c4b9c62de108f29eaa2ad59a6bc5fcf8cff7bc2bbc8
-  data.tar.gz: d83ce36125d77157290b60d0b66dbb01a7a3c8eac6d5f99c4c025e0e4cc511917d04c01a53357f74fd7554fcbf3ec91d5ead5b25c7a718565a6bf8b198de50fc
+  metadata.gz: c7ccf09ae0a94e0cdce47f66555681391ac29af9cb544b662e8f9cd127905cda5cf5923dc64500dcab15899c7c51d5d2458ae78b95cb40ca47b1ce792e35f52c
+  data.tar.gz: ba6d04f4fc107fe9e2daaf70bd06288f85a6ead011764ab1b975e1796e97fa8c289cc08186bbf23c6020670a585c1a48c22d2acbd28ed10c6ec09b97f07a2a47

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)

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/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

data/lib/graphql/introspection/dynamic_fields.rb

@@ -2,15 +2,10 @@
 module GraphQL
   module Introspection
     class DynamicFields < Introspection::BaseObject
-      field :__typename, String, "The name of this type", null: false, extras: [:irep_node]
+      field :__typename, String, "The name of this type", null: false
 
-      # `irep_node:` will be nil for the interpreter, since there is no such thing
-      def __typename(irep_node: nil)
-        if context.interpreter?
-          object.class.graphql_name
-        else
-          irep_node.owner_type.name
-        end
+      def __typename
+        object.class.graphql_name
       end
     end
   end

data/lib/graphql/introspection/entry_points.rb

@@ -11,24 +11,11 @@ module GraphQL
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.type_class.authorized_new(schema, @context)
+        schema_type.authorized_new(schema, @context)
       end
 
       def __type(name:)
-        return unless context.warden.reachable_type?(name)
-        type = context.warden.get_type(name)
-
-        if type && context.interpreter? && !type.is_a?(Module)
-          type = type.type_class || raise("Invariant: interpreter requires class-based type for #{name}")
-        end
-
-        # The interpreter provides this wrapping, other execution doesnt, so support both.
-        if type && !context.interpreter?
-          # Apply wrapping manually since this field isn't wrapped by instrumentation
-          type_type = context.schema.introspection_system.types["__Type"]
-          type = type_type.type_class.authorized_new(type, context)
-        end
-        type
+        context.warden.reachable_type?(name) ? context.warden.get_type(name) : nil
       end
     end
   end

data/lib/graphql/language/document_from_schema_definition.rb

@@ -321,23 +321,6 @@ module GraphQL
           end
         end
 
-        # This is just for printing legacy `.define { ... }` schemas, where `deprecation_reason` isn't added to `.directives`.
-        if !member.respond_to?(:directives) && member.respond_to?(:deprecation_reason) && (reason = member.deprecation_reason)
-          arguments = []
-
-          if reason != GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON
-            arguments << GraphQL::Language::Nodes::Argument.new(
-              name: "reason",
-              value: reason
-            )
-          end
-
-          dirs << GraphQL::Language::Nodes::Directive.new(
-            name: GraphQL::Directive::DeprecatedDirective.graphql_name,
-            arguments: arguments
-          )
-        end
-
         dirs
       end
 

data/lib/graphql/pagination/connections.rb

@@ -21,13 +21,6 @@ module GraphQL
       class ImplementationMissingError < GraphQL::Error
       end
 
-      def self.use(schema_defn)
-        if schema_defn.plugins.any? { |(plugin, args)| plugin == self }
-          GraphQL::Deprecation.warn("#{self} is now the default, remove `use #{self}` from #{caller(2,1).first}")
-        end
-        schema_defn.connections = self.new(schema: schema_defn)
-      end
-
       def initialize(schema:)
         @schema = schema
         @wrappers = {}
@@ -85,26 +78,7 @@ module GraphQL
             edge_class: edge_class_for_field(field),
           )
         else
-          begin
-            connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(items)
-            if parent.is_a?(GraphQL::Schema::Object)
-              parent = parent.object
-            end
-            connection_class.new(
-              items,
-              arguments,
-              field: field,
-              max_page_size: field.max_page_size,
-              parent: parent,
-              context: context,
-            )
-          rescue RuntimeError => err
-            if err.message.include?("No connection implementation to wrap")
-              raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
-            else
-              raise err
-            end
-          end
+          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
         end
       end
 
@@ -113,7 +87,7 @@ module GraphQL
       def edge_class_for_field(field)
         conn_type = field.type.unwrap
         conn_type_edge_type = conn_type.respond_to?(:edge_class) && conn_type.edge_class
-        if conn_type_edge_type && conn_type_edge_type != Relay::Edge
+        if conn_type_edge_type && conn_type_edge_type != Pagination::Connection::Edge
           conn_type_edge_type
         else
           nil