graphql 1.11.12 → 1.12.0

data/lib/graphql/schema.rb

@@ -21,6 +21,7 @@ require "graphql/schema/validation"
 require "graphql/schema/warden"
 require "graphql/schema/build_from_definition"
 
+require "graphql/schema/validator"
 require "graphql/schema/member"
 require "graphql/schema/wrapper"
 require "graphql/schema/list"
@@ -40,6 +41,7 @@ require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
+require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
 require "graphql/schema/type_membership"
 
@@ -80,6 +82,7 @@ module GraphQL
     extend GraphQL::Schema::Member::AcceptsDefinition
     extend GraphQL::Schema::Member::HasAstNode
     include GraphQL::Define::InstanceDefinable
+    extend GraphQL::Define::InstanceDefinable::DeprecatedDefine
     extend GraphQL::Schema::FindInheritedValue
 
     class DuplicateTypeNamesError < GraphQL::Error
@@ -157,7 +160,7 @@ module GraphQL
 
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
       :error_bubbling,
       :raise_definition_error,
@@ -196,7 +199,7 @@ module GraphQL
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
@@ -281,11 +284,11 @@ module GraphQL
       @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
       @lazy_methods.set(GraphQL::Execution::Lazy, :value)
       @cursor_encoder = Base64Encoder
-      # Default to the built-in execution strategy:
+      # For schema instances, default to legacy runtime modules
       @analysis_engine = GraphQL::Analysis
-      @query_execution_strategy = self.class.default_execution_strategy
-      @mutation_execution_strategy = self.class.default_execution_strategy
-      @subscription_execution_strategy = self.class.default_execution_strategy
+      @query_execution_strategy = GraphQL::Execution::Execute
+      @mutation_execution_strategy = GraphQL::Execution::Execute
+      @subscription_execution_strategy = GraphQL::Execution::Execute
       @default_mask = GraphQL::Schema::NullMask
       @rebuilding_artifacts = false
       @context_class = GraphQL::Query::Context
@@ -300,12 +303,11 @@ module GraphQL
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
     def interpreter?
-      @interpreter
+      query_execution_strategy == GraphQL::Execution::Interpreter &&
+        mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+        subscription_execution_strategy == GraphQL::Execution::Interpreter
     end
 
-    # @api private
-    attr_writer :interpreter
-
     def inspect
       "#<#{self.class.name} ...>"
     end
@@ -366,11 +368,11 @@ module GraphQL
       validator_opts = { schema: self }
       rules && (validator_opts[:rules] = rules)
       validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query, timeout: validate_timeout, max_errors: validate_max_errors)
+      res = validator.validate(query, timeout: validate_timeout)
       res[:errors]
     end
 
-    def define(**kwargs, &block)
+    def deprecated_define(**kwargs, &block)
       super
       ensure_defined
       # Assert that all necessary configs are present:
@@ -709,7 +711,7 @@ module GraphQL
     alias :_schema_class :class
     def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
-    def_delegators :_schema_class, :error_handler
+    def_delegators :_schema_class, :error_handler, :rescues
 
 
     # Given this schema member, find the class-based definition object
@@ -787,9 +789,8 @@ module GraphQL
     # @param default_resolve [<#call(type, field, obj, args, ctx)>] A callable for handling field resolution
     # @param parser [Object] An object for handling definition string parsing (must respond to `parse`)
     # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
-    # @param interpreter [Boolean] If false, the legacy {Execution::Execute} runtime will be used
     # @return [Class] the schema described by `document`
-    def self.from_definition(definition_or_path, default_resolve: nil, interpreter: true, parser: GraphQL.default_parser, using: {})
+    def self.from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
       # If the file ends in `.graphql`, treat it like a filepath
       if definition_or_path.end_with?(".graphql")
         GraphQL::Schema::BuildFromDefinition.from_definition_path(
@@ -797,7 +798,6 @@ module GraphQL
           default_resolve: default_resolve,
           parser: parser,
           using: using,
-          interpreter: interpreter,
         )
       else
         GraphQL::Schema::BuildFromDefinition.from_definition(
@@ -805,7 +805,6 @@ module GraphQL
           default_resolve: default_resolve,
           parser: parser,
           using: using,
-          interpreter: interpreter,
         )
       end
     end
@@ -951,7 +950,6 @@ module GraphQL
         schema_defn.mutation = mutation && mutation.graphql_definition
         schema_defn.subscription = subscription && subscription.graphql_definition
         schema_defn.validate_timeout = validate_timeout
-        schema_defn.validate_max_errors = validate_max_errors
         schema_defn.max_complexity = max_complexity
         schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
@@ -1120,15 +1118,14 @@ module GraphQL
             type.possible_types(context: context)
           else
             stored_possible_types = own_possible_types[type.graphql_name]
-            visible_possible_types = if stored_possible_types && type.kind.interface?
-              stored_possible_types.select do |possible_type|
-                # Use `.graphql_name` comparison to match legacy vs class-based types.
-                # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
-                possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
-              end
-            else
-              stored_possible_types
-            end
+            visible_possible_types = stored_possible_types.select do |possible_type|
+              next true unless type.kind.interface?
+              next true unless possible_type.kind.object?
+
+              # Use `.graphql_name` comparison to match legacy vs class-based types.
+              # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+              possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+            end if stored_possible_types
             visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
@@ -1159,6 +1156,14 @@ module GraphQL
         end
       end
 
+      # @api private
+      # @see GraphQL::Dataloader
+      def dataloader_class
+        @dataloader_class || GraphQL::Dataloader::NullDataloader
+      end
+
+      attr_writer :dataloader_class
+
       def references_to(to_type = nil, from: nil)
         @own_references_to ||= Hash.new { |h, k| h[k] = [] }
         if to_type
@@ -1287,19 +1292,6 @@ module GraphQL
         end
       end
 
-      attr_writer :validate_max_errors
-
-      def validate_max_errors(new_validate_max_errors = nil)
-        if new_validate_max_errors
-          @validate_max_errors = new_validate_max_errors
-        elsif defined?(@validate_max_errors)
-          @validate_max_errors
-        else
-          find_inherited_value(:validate_max_errors)
-        end
-      end
-
-
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)
@@ -1315,7 +1307,7 @@ module GraphQL
       attr_writer :analysis_engine
 
       def analysis_engine
-        @analysis_engine || find_inherited_value(:analysis_engine, GraphQL::Analysis)
+        @analysis_engine || find_inherited_value(:analysis_engine, self.default_analysis_engine)
       end
 
       def using_ast_analysis?
@@ -1323,11 +1315,9 @@ module GraphQL
       end
 
       def interpreter?
-        if defined?(@interpreter)
-          @interpreter
-        else
-          find_inherited_value(:interpreter?, false)
-        end
+        query_execution_strategy == GraphQL::Execution::Interpreter &&
+          mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+          subscription_execution_strategy == GraphQL::Execution::Interpreter
       end
 
       attr_writer :interpreter
@@ -1411,7 +1401,15 @@ module GraphQL
         if superclass <= GraphQL::Schema
           superclass.default_execution_strategy
         else
-          @default_execution_strategy ||= GraphQL::Execution::Execute
+          @default_execution_strategy ||= GraphQL::Execution::Interpreter
+        end
+      end
+
+      def default_analysis_engine
+        if superclass <= GraphQL::Schema
+          superclass.default_analysis_engine
+        else
+          @default_analysis_engine ||= GraphQL::Analysis::AST
         end
       end
 
@@ -1565,6 +1563,10 @@ module GraphQL
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        if instrument_step == :field
+          warn "Field instrumentation (#{instrumenter.inspect}) will be removed in GraphQL-Ruby 2.0, please upgrade to field extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
+        end
+
         step = if instrument_step == :field && options[:after_built_ins]
           :field_after_built_ins
         else
@@ -1586,9 +1588,12 @@ module GraphQL
 
       # Attach a single directive to this schema
       # @param new_directive [Class]
+      # @return void
       def directive(new_directive)
-        add_type_and_traverse(new_directive, root: false)
-        own_directives[new_directive.graphql_name] = new_directive
+        own_directives[new_directive.graphql_name] ||= begin
+          add_type_and_traverse(new_directive, root: false)
+          new_directive
+        end
       end
 
       def default_directives
@@ -1620,6 +1625,7 @@ module GraphQL
 
       def middleware(new_middleware = nil)
         if new_middleware
+          warn "Middleware will be removed in GraphQL-Ruby 2.0, please upgrade to Field Extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
           own_middleware << new_middleware
         else
           # TODO make sure this is cached when running a query
@@ -1719,6 +1725,7 @@ module GraphQL
           else
             @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
             @lazy_methods.set(GraphQL::Execution::Lazy, :value)
+            @lazy_methods.set(GraphQL::Dataloader::Request, :load)
           end
         end
         @lazy_methods
@@ -1915,13 +1922,16 @@ module GraphQL
           end
         else
           own_types[type.graphql_name] = type
+          add_directives_from(type)
           if type.kind.fields?
             type.fields.each do |name, field|
               field_type = field.type.unwrap
               references_to(field_type, from: field)
               field_path = path + [name]
               add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              add_directives_from(field)
               field.arguments.each do |arg_name, arg|
+                add_directives_from(arg)
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
                 add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg_name])
@@ -1930,6 +1940,7 @@ module GraphQL
           end
           if type.kind.input_object?
             type.arguments.each do |arg_name, arg|
+              add_directives_from(arg)
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
               add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg_name])
@@ -1967,8 +1978,20 @@ module GraphQL
           end
         end
       end
+
+      def add_directives_from(owner)
+        owner.directives.each { |dir| directive(dir.class) }
+      end
     end
 
+    def dataloader_class
+      self.class.dataloader_class
+    end
+
+    # Install these here so that subclasses will also install it.
+    use(GraphQL::Execution::Errors)
+    use(GraphQL::Pagination::Connections)
+
     protected
 
     def rescues?

data/lib/graphql/static_validation/base_visitor.rb

@@ -205,9 +205,6 @@ module GraphQL
       private
 
       def add_error(error, path: nil)
-        if @context.too_many_errors?
-          throw :too_many_validation_errors
-        end
         error.path ||= (path || @path.dup)
         context.errors << error
       end

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -193,26 +193,26 @@ module GraphQL
           if node1.name != node2.name
             errored_nodes = [node1.name, node2.name].sort.join(" or ")
             msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
+            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
               conflicts: errored_nodes
-            ))
+            )
           end
 
           if !same_arguments?(node1, node2)
             args = [serialize_field_args(node1), serialize_field_args(node2)]
             conflicts = args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
             msg = "Field '#{response_key}' has an argument conflict: #{conflicts}?"
-            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
+            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
               conflicts: conflicts
-            ))
+            )
           end
         end
 

data/lib/graphql/static_validation/rules/fragments_are_finite.rb

@@ -7,12 +7,12 @@ module GraphQL
         dependency_map = context.dependencies
         dependency_map.cyclical_definitions.each do |defn|
           if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-            add_error(GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+            context.errors << GraphQL::StaticValidation::FragmentsAreFiniteError.new(
               "Fragment #{defn.name} contains an infinite loop",
               nodes: defn.node,
               path: defn.path,
               name: defn.name
-            ))
+            )
           end
         end
       end

data/lib/graphql/static_validation/validation_context.rb

@@ -19,11 +19,10 @@ module GraphQL
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
-      def initialize(query, visitor_class, max_errors)
+      def initialize(query, visitor_class)
         @query = query
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
-        @max_errors = max_errors || Float::INFINITY
         @on_dependency_resolve_handlers = []
         @visitor = visitor_class.new(document, self)
       end
@@ -39,10 +38,6 @@ module GraphQL
       def validate_literal(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end
-
-      def too_many_errors?
-        @errors.length >= @max_errors
-      end
     end
   end
 end

data/lib/graphql/static_validation/validator.rb

@@ -22,9 +22,8 @@ module GraphQL
       # @param query [GraphQL::Query]
       # @param validate [Boolean]
       # @param timeout [Float] Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
-      # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
-      def validate(query, validate: true, timeout: nil, max_errors: nil)
+      def validate(query, validate: true, timeout: nil)
         query.trace("validate", { validate: validate, query: query }) do
           can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
           errors = if validate == false && can_skip_rewrite
@@ -33,26 +32,25 @@ module GraphQL
             rules_to_use = validate ? @rules : []
             visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
 
-            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
 
             begin
               # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
               # A timeout value of 0 or nil will execute the block without any timeout.
               Timeout::timeout(timeout) do
-
-                catch(:too_many_validation_errors) do
-                  # Attach legacy-style rules.
-                  # Only loop through rules if it has legacy-style rules
-                  unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
-                    legacy_rules.each do |rule_class_or_module|
-                      if rule_class_or_module.method_defined?(:validate)
-                        rule_class_or_module.new.validate(context)
-                      end
+                # Attach legacy-style rules.
+                # Only loop through rules if it has legacy-style rules
+                unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
+                  legacy_rules.each do |rule_class_or_module|
+                    if rule_class_or_module.method_defined?(:validate)
+                      warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
+                      warn "  -> Legacy validator: #{rule_class_or_module}"
+                      rule_class_or_module.new.validate(context)
                     end
                   end
-
-                  context.visitor.visit
                 end
+
+                context.visitor.visit
               end
             rescue Timeout::Error
               handle_timeout(query, context)

data/lib/graphql/subscriptions.rb

@@ -26,7 +26,9 @@ module GraphQL
 
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
       defn.instrument(:query, instrumentation)
-      defn.instrument(:field, instrumentation)
+      if !schema.is_a?(Class)
+        defn.instrument(:field, instrumentation)
+      end
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary
@@ -107,31 +109,26 @@ module GraphQL
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      result = nil
-      # this will be set to `false` unless `.execute` is terminated
-      # with a `throw :graphql_subscription_unsubscribed`
-      unsubscribed = true
-      catch(:graphql_subscription_unsubscribed) do
-        catch(:graphql_no_subscription_update) do
-          # Re-evaluate the saved query,
-          # but if it terminates early with a `throw`,
-          # it will stay `nil`
-          result = @schema.execute(
-            query: query_string,
-            context: context,
-            subscription_topic: event.topic,
-            operation_name: operation_name,
-            variables: variables,
-            root_value: object,
-          )
-        end
-        unsubscribed = false
+      result = @schema.execute(
+        query: query_string,
+        context: context,
+        subscription_topic: event.topic,
+        operation_name: operation_name,
+        variables: variables,
+        root_value: object,
+      )
+      subscriptions_context = result.context.namespace(:subscriptions)
+      if subscriptions_context[:no_update]
+        result = nil
       end
 
+      unsubscribed = subscriptions_context[:unsubscribed]
+
       if unsubscribed
         # `unsubscribe` was called, clean up on our side
         # TODO also send `{more: false}` to client?
         delete_subscription(subscription_id)
+        result = nil
       end
 
       result

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -57,7 +57,7 @@ module GraphQL
       def platform_field_key(type, field)
         "graphql.#{type.graphql_name}.#{field.graphql_name}"
       end
-      
+
       def platform_authorized_key(type)
         "graphql.authorized.#{type.graphql_name}"
       end
@@ -112,6 +112,8 @@ module GraphQL
             graphql_query_string(data[key])
           when :multiplex
             graphql_multiplex(data[key])
+          when :path
+            [key, data[key].join(".")]
           else
             [key, data[key]]
           end

data/lib/graphql/tracing/platform_tracing.rb

@@ -96,7 +96,9 @@ module GraphQL
 
       def self.use(schema_defn, options = {})
         tracer = self.new(**options)
-        schema_defn.instrument(:field, tracer)
+        if !schema_defn.is_a?(Class)
+          schema_defn.instrument(:field, tracer)
+        end
         schema_defn.tracer(tracer)
       end
 

data/lib/graphql/tracing/skylight_tracing.rb

@@ -18,7 +18,7 @@ module GraphQL
       #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
       #   It can also be specified per-query with `context[:set_skylight_endpoint_name]`.
       def initialize(options = {})
-        warn("GraphQL::Tracing::SkylightTracing is deprecated, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
+        warn("GraphQL::Tracing::SkylightTracing is deprecated and will be removed in GraphQL-Ruby 2.0, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
         @set_endpoint_name = options.fetch(:set_endpoint_name, false)
         super
       end

data/lib/graphql/tracing.rb

@@ -42,8 +42,8 @@ module GraphQL
   # execute_multiplex | `{ multiplex: GraphQL::Execution::Multiplex }`
   # execute_query | `{ query: GraphQL::Query }`
   # execute_query_lazy | `{ query: GraphQL::Query?, multiplex: GraphQL::Execution::Multiplex? }`
-  # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphQL::Query?, path: Array<String, Integer>?}`
-  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphQL::Query?, path: Array<String, Integer>?}`
+  # execute_field | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
+  # execute_field_lazy | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
   # authorized | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
   # authorized_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
   # resolve_type | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`

data/lib/graphql/types/relay/base_connection.rb

@@ -27,98 +27,8 @@ module GraphQL
       #   end
       #
       # @see Relay::BaseEdge for edge types
-      class BaseConnection < Types::Relay::BaseObject
-        extend Forwardable
-        def_delegators :@object, :cursor_from_node, :parent
-
-        class << self
-          # @return [Class]
-          attr_reader :node_type
-
-          # @return [Class]
-          attr_reader :edge_class
-
-          # Configure this connection to return `edges` and `nodes` based on `edge_type_class`.
-          #
-          # This method will use the inputs to create:
-          # - `edges` field
-          # - `nodes` field
-          # - description
-          #
-          # It's called when you subclass this base connection, trying to use the
-          # class name to set defaults. You can call it again in the class definition
-          # to override the default (or provide a value, if the default lookup failed).
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true, node_nullable: true)
-            # Set this connection's graphql name
-            node_type_name = node_type.graphql_name
-
-            @node_type = node_type
-            @edge_type = edge_type_class
-            @edge_class = edge_class
-
-            field :edges, [edge_type_class, null: true],
-              null: true,
-              description: "A list of edges.",
-              edge_class: edge_class
-
-            define_nodes_field(node_nullable) if nodes_field
-
-            description("The connection type for #{node_type_name}.")
-          end
-
-          # Filter this list according to the way its node type would scope them
-          def scope_items(items, context)
-            node_type.scope_items(items, context)
-          end
-
-          # Add the shortcut `nodes` field to this connection and its subclasses
-          def nodes_field
-            define_nodes_field
-          end
-
-          def authorized?(obj, ctx)
-            true # Let nodes be filtered out
-          end
-
-          def accessible?(ctx)
-            node_type.accessible?(ctx)
-          end
-
-          def visible?(ctx)
-            node_type.visible?(ctx)
-          end
-
-          private
-
-          def define_nodes_field(nullable = true)
-            type = nullable ? [@node_type, null: true] : [@node_type]
-            field :nodes, type,
-              null: nullable,
-              description: "A list of nodes.",
-              connection: false
-          end
-        end
-
-        field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
-
-        # By default this calls through to the ConnectionWrapper's edge nodes method,
-        # but sometimes you need to override it to support the `nodes` field
-        def nodes
-          @object.edge_nodes
-        end
-
-        def edges
-          if @object.is_a?(GraphQL::Pagination::Connection)
-            @object.edges
-          elsif context.interpreter?
-            context.schema.after_lazy(object.edge_nodes) do |nodes|
-              nodes.map { |n| self.class.edge_class.new(n, object) }
-            end
-          else
-            # This is done by edges_instrumentation
-            @object.edge_nodes
-          end
-        end
+      class BaseConnection < Schema::Object
+        include ConnectionBehaviors
       end
     end
   end