graphql 1.9.0 → 2.1.1

data/lib/graphql/schema/timeout_middleware.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-require "delegate"
-
-module GraphQL
-  class Schema
-    # This middleware will stop resolving new fields after `max_seconds` have elapsed.
-    # After the time has passed, any remaining fields will be `nil`, with errors added
-    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
-    # you'll get a partial response.
-    #
-    # You can provide a block which will be called with any timeout errors that occur.
-    #
-    # Note that this will stop a query _in between_ field resolutions, but
-    # it doesn't interrupt long-running `resolve` functions. Be sure to use
-    # timeout options for external connections. For more info, see
-    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
-    #
-    # @example Stop resolving fields after 2 seconds
-    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2)
-    #
-    # @example Notifying Bugsnag on a timeout
-    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware(max_seconds: 1.5) do |timeout_error, query|
-    #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
-    #   end
-    #
-    class TimeoutMiddleware
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
-      def initialize(max_seconds:, context_key: nil, &block)
-        @max_seconds = max_seconds
-        if context_key
-          warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
-        end
-        @error_handler = block
-      end
-
-      def call(parent_type, parent_object, field_definition, field_args, query_context)
-        ns = query_context.namespace(self.class)
-        timeout_at = ns[:timeout_at] ||= Time.now + @max_seconds
-
-        if timeout_at < Time.now
-          on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
-        else
-          yield
-        end
-      end
-
-      # This is called when a field _would_ be resolved, except that we're over the time limit.
-      # @return [GraphQL::Schema::TimeoutMiddleware::TimeoutError] An error whose message will be added to the `errors` key
-      def on_timeout(parent_type, parent_object, field_definition, field_args, field_context)
-        err = GraphQL::Schema::TimeoutMiddleware::TimeoutError.new(parent_type, field_definition)
-        if @error_handler
-          query_proxy = TimeoutQueryProxy.new(field_context.query, field_context)
-          @error_handler.call(err, query_proxy)
-        end
-        err
-      end
-
-      # This behaves like {GraphQL::Query} but {#context} returns
-      # the _field-level_ context, not the query-level context.
-      # This means you can reliably get the `irep_node` and `path`
-      # from it after the fact.
-      class TimeoutQueryProxy < SimpleDelegator
-        def initialize(query, ctx)
-          @context = ctx
-          super(query)
-        end
-
-        attr_reader :context
-      end
-
-      # This error is raised when a query exceeds `max_seconds`.
-      # Since it's a child of {GraphQL::ExecutionError},
-      # its message will be added to the response's `errors` key.
-      #
-      # To raise an error that will stop query resolution, use a custom block
-      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
-      # such as `RuntimeError`.
-      class TimeoutError < GraphQL::ExecutionError
-        def initialize(parent_type, field_defn)
-          super("Timeout on #{parent_type.name}.#{field_defn.name}")
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/traversal.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # Visit the members of this schema and build up artifacts for runtime.
-    # @api private
-    class Traversal
-      # @return [Hash<String => GraphQL::BaseType]
-      attr_reader :type_map
-
-      # @return [Hash<String => Hash<String => GraphQL::Field>>]
-      attr_reader :instrumented_field_map
-
-      # @return [Hash<String => Array<GraphQL::Field || GraphQL::Argument || GraphQL::Directive>]
-      attr_reader :type_reference_map
-
-      # @return [Hash<String => Array<GraphQL::BaseType>]
-      attr_reader :union_memberships
-
-
-      # @param schema [GraphQL::Schema]
-      def initialize(schema, introspection: true)
-        @schema = schema
-        @introspection = introspection
-        built_in_insts = [
-          GraphQL::Relay::ConnectionInstrumentation,
-          GraphQL::Relay::EdgesInstrumentation,
-          GraphQL::Relay::Mutation::Instrumentation,
-        ]
-
-        if schema.query_execution_strategy != GraphQL::Execution::Interpreter
-          built_in_insts << GraphQL::Schema::Member::Instrumentation
-        end
-
-        @field_instrumenters =
-          schema.instrumenters[:field] +
-            built_in_insts +
-            schema.instrumenters[:field_after_built_ins]
-
-        # These fields have types specified by _name_,
-        # So we need to inspect the schema and find those types,
-        # then update their references.
-        @late_bound_fields = []
-        @type_map = {}
-        @instrumented_field_map = Hash.new { |h, k| h[k] = {} }
-        @type_reference_map = Hash.new { |h, k| h[k] = [] }
-        @union_memberships = Hash.new { |h, k| h[k] = [] }
-        visit(schema, schema, nil)
-        resolve_late_bound_fields
-      end
-
-      private
-
-      # A brute-force appraoch to late binding.
-      # Just keep trying the whole list, hoping that they
-      # eventually all resolve.
-      # This could be replaced with proper dependency tracking.
-      def resolve_late_bound_fields
-        # This is a bit tricky, with the writes going to internal state.
-        prev_late_bound_fields = @late_bound_fields
-        # Things might get added here during `visit...`
-        # or they might be added manually if we can't find them by hand
-        @late_bound_fields = []
-        prev_late_bound_fields.each do |(owner_type, field_defn, dynamic_field)|
-          if @type_map.key?(field_defn.type.unwrap.name)
-            late_bound_return_type = field_defn.type
-            resolved_type = @type_map.fetch(late_bound_return_type.unwrap.name)
-            wrapped_resolved_type = rewrap_resolved_type(late_bound_return_type, resolved_type)
-            # Update the field definition in place? :thinking_face:
-            field_defn.type = wrapped_resolved_type
-            visit_field_on_type(@schema, owner_type, field_defn, dynamic_field: dynamic_field)
-          else
-            @late_bound_fields << [owner_type, field_defn, dynamic_field]
-          end
-        end
-
-        if @late_bound_fields.any?
-          # If we visited each field and failed to resolve _any_,
-          # then we're stuck.
-          if @late_bound_fields == prev_late_bound_fields
-            type_names = prev_late_bound_fields.map { |f| f[1] }.map(&:type).map(&:unwrap).map(&:name).uniq
-            raise <<-ERR
-Some late-bound types couldn't be resolved:
-
-- #{type_names}
-- Found __* types: #{@type_map.keys.select { |k| k.start_with?("__") }}
-            ERR
-          else
-            resolve_late_bound_fields
-          end
-        end
-      end
-
-      # The late-bound type may be wrapped with list or non-null types.
-      # Apply the same wrapping to the resolve type and
-      # return the maybe-wrapped type
-      def rewrap_resolved_type(late_bound_type, resolved_inner_type)
-        case late_bound_type
-        when GraphQL::NonNullType
-          rewrap_resolved_type(late_bound_type.of_type, resolved_inner_type).to_non_null_type
-        when GraphQL::ListType
-          rewrap_resolved_type(late_bound_type.of_type, resolved_inner_type).to_list_type
-        when GraphQL::Schema::LateBoundType
-          resolved_inner_type
-        else
-          raise "Unexpected late_bound_type: #{late_bound_type.inspect} (#{late_bound_type.class})"
-        end
-      end
-
-      def visit(schema, member, context_description)
-        case member
-        when GraphQL::Schema
-          member.directives.each { |name, directive| visit(schema, directive, "Directive #{name}") }
-          # Find the starting points, then visit them
-          visit_roots = [member.query, member.mutation, member.subscription]
-          if @introspection
-            introspection_types = schema.introspection_system.object_types
-            visit_roots.concat(introspection_types)
-            if member.query
-              member.introspection_system.entry_points.each do |introspection_field|
-                # Visit this so that arguments class is preconstructed
-                # Skip validation since it begins with "__"
-                visit_field_on_type(schema, member.query, introspection_field, dynamic_field: true)
-              end
-            end
-          end
-          visit_roots.concat(member.orphan_types)
-          visit_roots.compact!
-          visit_roots.each { |t| visit(schema, t, t.name) }
-        when GraphQL::Directive
-          member.arguments.each do |name, argument|
-            @type_reference_map[argument.type.unwrap.to_s] << argument
-            visit(schema, argument.type, "Directive argument #{member.name}.#{name}")
-          end
-          # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
-          # to be passed to a resolver proc
-          GraphQL::Query::Arguments.construct_arguments_class(member)
-        when GraphQL::BaseType
-          type_defn = member.unwrap
-          prev_type = @type_map[type_defn.name]
-          # Continue to visit this type if it's the first time we've seen it:
-          if prev_type.nil?
-            validate_type(type_defn, context_description)
-            @type_map[type_defn.name] = type_defn
-            case type_defn
-            when GraphQL::ObjectType
-              type_defn.interfaces.each { |i| visit(schema, i, "Interface on #{type_defn.name}") }
-              visit_fields(schema, type_defn)
-            when GraphQL::InterfaceType
-              visit_fields(schema, type_defn)
-              type_defn.orphan_types.each do |t|
-                visit(schema, t, "Orphan type for #{type_defn.name}")
-              end
-            when GraphQL::UnionType
-              type_defn.possible_types.each do |t|
-                @union_memberships[t.name] << type_defn
-                visit(schema, t, "Possible type for #{type_defn.name}")
-              end
-            when GraphQL::InputObjectType
-              type_defn.arguments.each do |name, arg|
-                @type_reference_map[arg.type.unwrap.to_s] << arg
-                visit(schema, arg.type, "Input field #{type_defn.name}.#{name}")
-              end
-
-              # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
-              # to be passed to a resolver proc
-              if type_defn.arguments_class.nil?
-                GraphQL::Query::Arguments.construct_arguments_class(type_defn)
-              end
-            end
-          elsif !prev_type.equal?(type_defn)
-            # If the previous entry in the map isn't the same object we just found, raise.
-            raise("Duplicate type definition found for name '#{type_defn.name}' at '#{context_description}' (#{prev_type.metadata[:type_class] || prev_type}, #{type_defn.metadata[:type_class] || type_defn})")
-          end
-        when Class
-          if member.respond_to?(:graphql_definition)
-            graphql_member = member.graphql_definition
-            visit(schema, graphql_member, context_description)
-          else
-            raise GraphQL::Schema::InvalidTypeError.new("Unexpected traversal member: #{member} (#{member.class.name})")
-          end
-        else
-          message = "Unexpected schema traversal member: #{member} (#{member.class.name})"
-          raise GraphQL::Schema::InvalidTypeError.new(message)
-        end
-      end
-
-      def visit_fields(schema, type_defn)
-        type_defn.all_fields.each do |field_defn|
-          visit_field_on_type(schema, type_defn, field_defn)
-        end
-      end
-
-      def visit_field_on_type(schema, type_defn, field_defn, dynamic_field: false)
-        base_return_type = field_defn.type.unwrap
-        if base_return_type.is_a?(GraphQL::Schema::LateBoundType)
-          @late_bound_fields << [type_defn, field_defn, dynamic_field]
-          return
-        end
-        if dynamic_field
-          # Don't apply instrumentation to dynamic fields since they're shared constants
-          instrumented_field_defn = field_defn
-        else
-          instrumented_field_defn = @field_instrumenters.reduce(field_defn) do |defn, inst|
-            inst.instrument(type_defn, defn)
-          end
-          @instrumented_field_map[type_defn.name][instrumented_field_defn.name] = instrumented_field_defn
-        end
-        @type_reference_map[instrumented_field_defn.type.unwrap.name] << instrumented_field_defn
-        visit(schema, instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
-        instrumented_field_defn.arguments.each do |name, arg|
-          @type_reference_map[arg.type.unwrap.to_s] << arg
-          visit(schema, arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
-        end
-
-        # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
-        # to be passed to a resolver proc
-        GraphQL::Query::Arguments.construct_arguments_class(instrumented_field_defn)
-      end
-
-      def validate_type(member, context_description)
-        error_message = GraphQL::Schema::Validation.validate(member)
-        if error_message
-          raise GraphQL::Schema::InvalidTypeError.new("#{context_description} is invalid: #{error_message}")
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/validation.rb

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # This module provides a function for validating GraphQL types.
-    #
-    # Its {RULES} contain objects that respond to `#call(type)`. Rules are
-    # looked up for given types (by class ancestry), then applied to
-    # the object until an error is returned.
-    class Validation
-      # Lookup the rules for `object` based on its class,
-      # Then returns an error message or `nil`
-      # @param object [Object] something to be validated
-      # @return [String, Nil] error message, if there was one
-      def self.validate(object)
-        rules = RULES.reduce([]) do |memo, (parent_class, validations)|
-          memo + (object.is_a?(parent_class) ? validations : [])
-        end
-        # Stops after the first error
-        rules.reduce(nil) { |memo, rule| memo || rule.call(object) }
-      end
-
-      module Rules
-        # @param property_name [Symbol] The method to validate
-        # @param allowed_classes [Class] Classes which the return value may be an instance of
-        # @return [Proc] A proc which will validate the input by calling `property_name` and asserting it is an instance of one of `allowed_classes`
-        def self.assert_property(property_name, *allowed_classes)
-          # Hide LateBoundType from user-facing errors
-          allowed_classes_message = allowed_classes.map(&:name).reject {|n| n.include?("LateBoundType") }.join(" or ")
-          ->(obj) {
-            property_value = obj.public_send(property_name)
-            is_valid_value = allowed_classes.any? { |allowed_class| property_value.is_a?(allowed_class) }
-            is_valid_value ? nil : "#{property_name} must return #{allowed_classes_message}, not #{property_value.class.name} (#{property_value.inspect})"
-          }
-        end
-
-        # @param property_name [Symbol] The method whose return value will be validated
-        # @param from_class [Class] The class for keys in the return value
-        # @param to_class [Class] The class for values in the return value
-        # @return [Proc] A proc to validate that validates the input by calling `property_name` and asserting that the return value is a Hash of `{from_class => to_class}` pairs
-        def self.assert_property_mapping(property_name, from_class, to_class)
-          ->(obj) {
-            property_value = obj.public_send(property_name)
-            if !property_value.is_a?(Hash)
-              "#{property_name} must be a hash of {#{from_class.name} => #{to_class.name}}, not a #{property_value.class.name} (#{property_value.inspect})"
-            else
-              invalid_key, invalid_value = property_value.find { |key, value| !key.is_a?(from_class) || !value.is_a?(to_class) }
-              if invalid_key
-                "#{property_name} must map #{from_class} => #{to_class}, not #{invalid_key.class.name} => #{invalid_value.class.name} (#{invalid_key.inspect} => #{invalid_value.inspect})"
-              else
-                nil # OK
-              end
-            end
-          }
-        end
-
-        # @param property_name [Symbol] The method whose return value will be validated
-        # @param list_member_class [Class] The class which each member of the returned array should be an instance of
-        # @return [Proc] A proc to validate the input by calling `property_name` and asserting that the return is an Array of `list_member_class` instances
-        def self.assert_property_list_of(property_name, list_member_class)
-          ->(obj) {
-            property_value = obj.public_send(property_name)
-            if !property_value.is_a?(Array)
-              "#{property_name} must be an Array of #{list_member_class.name}, not a #{property_value.class.name} (#{property_value.inspect})"
-            else
-              invalid_member = property_value.find { |value| !value.is_a?(list_member_class) }
-              if invalid_member
-                "#{property_name} must contain #{list_member_class.name}, not #{invalid_member.class.name} (#{invalid_member.inspect})"
-              else
-                nil # OK
-              end
-            end
-          }
-        end
-
-        def self.assert_named_items_are_valid(item_name, get_items_proc)
-          ->(type) {
-            items = get_items_proc.call(type)
-            error_message = nil
-            items.each do |item|
-              item_message = GraphQL::Schema::Validation.validate(item)
-              if item_message
-                error_message = "#{item_name} #{item.name.inspect} #{item_message}"
-                break
-              end
-            end
-            error_message
-          }
-        end
-
-        FIELDS_ARE_VALID = Rules.assert_named_items_are_valid("field", ->(type) { type.all_fields })
-
-        HAS_ONE_OR_MORE_POSSIBLE_TYPES = ->(type) {
-          type.possible_types.length >= 1 ? nil : "must have at least one possible type"
-        }
-
-        NAME_IS_STRING = Rules.assert_property(:name, String)
-        DESCRIPTION_IS_STRING_OR_NIL = Rules.assert_property(:description, String, NilClass)
-        ARGUMENTS_ARE_STRING_TO_ARGUMENT = Rules.assert_property_mapping(:arguments, String, GraphQL::Argument)
-        ARGUMENTS_ARE_VALID =  Rules.assert_named_items_are_valid("argument", ->(type) { type.arguments.values })
-
-        DEFAULT_VALUE_IS_VALID_FOR_TYPE = ->(type) {
-          if !type.default_value.nil? && type.type.is_a?(NonNullType)
-            return %Q(Variable #{type.name} of type "#{type.type}" is required and will not use the default value. Perhaps you meant to use type "#{type.type.of_type}".)
-          end
-
-          if !type.default_value.nil?
-            coerced_value = begin
-              type.type.coerce_isolated_result(type.default_value)
-            rescue => ex
-              ex
-            end
-
-            if coerced_value.nil? || coerced_value.is_a?(StandardError)
-              msg = "default value #{type.default_value.inspect} is not valid for type #{type.type}"
-              msg += " (#{coerced_value})" if coerced_value.is_a?(StandardError)
-              msg
-            end
-          end
-        }
-
-        TYPE_IS_VALID_INPUT_TYPE = ->(type) {
-          outer_type = type.type
-          inner_type = outer_type.is_a?(GraphQL::BaseType) ? outer_type.unwrap : nil
-
-          case inner_type
-          when GraphQL::ScalarType, GraphQL::InputObjectType, GraphQL::EnumType
-            # OK
-          else
-            "type must be a valid input type (Scalar or InputObject), not #{outer_type.class} (#{outer_type})"
-          end
-        }
-
-        SCHEMA_CAN_RESOLVE_TYPES = ->(schema) {
-          if schema.types.values.any? { |type| type.kind.abstract? } && schema.resolve_type_proc.nil?
-            "schema contains Interfaces or Unions, so you must define a `resolve_type -> (obj, ctx) { ... }` function"
-          else
-            # :+1:
-          end
-        }
-
-        SCHEMA_CAN_FETCH_IDS = ->(schema) {
-          has_node_field = schema.query && schema.query.all_fields.any?(&:relay_node_field)
-          if has_node_field && schema.object_from_id_proc.nil?
-            "schema contains `node(id:...)` field, so you must define a `object_from_id -> (id, ctx) { ... }` function"
-          else
-            # :rocket:
-          end
-        }
-
-        SCHEMA_CAN_GENERATE_IDS = ->(schema) {
-          has_id_field = schema.types.values.any? { |t| t.kind.fields? && t.all_fields.any? { |f| f.resolve_proc.is_a?(GraphQL::Relay::GlobalIdResolve) } }
-          if has_id_field && schema.id_from_object_proc.nil?
-            "schema contains `global_id_field`, so you must define a `id_from_object -> (obj, type, ctx) { ... }` function"
-          else
-            # :ok_hand:
-          end
-        }
-
-        SCHEMA_INSTRUMENTERS_ARE_VALID = ->(schema) {
-          errs = []
-          schema.instrumenters[:query].each do |inst|
-            if !inst.respond_to?(:before_query) || !inst.respond_to?(:after_query)
-              errs << "`instrument(:query, #{inst})` is invalid: must respond to `before_query(query)` and `after_query(query)` "
-            end
-          end
-
-          schema.instrumenters[:field].each do |inst|
-            if !inst.respond_to?(:instrument)
-              errs << "`instrument(:field, #{inst})` is invalid: must respond to `instrument(type, field)`"
-            end
-          end
-
-          if errs.any?
-            errs.join("Invalid instrumenters:\n" + errs.join("\n"))
-          else
-            nil
-          end
-        }
-
-        RESERVED_TYPE_NAME = ->(type) {
-          if type.name.start_with?('__') && !type.introspection?
-            # TODO: make this a hard failure in a later version
-            warn("Name #{type.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
-            nil
-          else
-            # ok name
-          end
-        }
-
-        RESERVED_NAME = ->(named_thing) {
-          if named_thing.name.start_with?('__')
-            # TODO: make this a hard failure in a later version
-            warn("Name #{named_thing.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
-            nil
-          else
-            # no worries
-          end
-        }
-
-        INTERFACES_ARE_IMPLEMENTED = ->(obj_type) {
-          field_errors = []
-          obj_type.interfaces.each do |interface_type|
-            interface_type.fields.each do |field_name, field_defn|
-              object_field = obj_type.get_field(field_name)
-              if object_field.nil?
-                field_errors << %|"#{field_name}" is required by #{interface_type.name} but not implemented by #{obj_type.name}|
-              elsif !GraphQL::Execution::Typecast.subtype?(field_defn.type, object_field.type)
-                field_errors << %|"#{field_name}" is required by #{interface_type.name} to return #{field_defn.type} but #{obj_type.name}.#{field_name} returns #{object_field.type}|
-              else
-                field_defn.arguments.each do |arg_name, arg_defn|
-                  object_field_arg = object_field.arguments[arg_name]
-                  if object_field_arg.nil?
-                    field_errors << %|"#{arg_name}" argument is required by #{interface_type.name}.#{field_name} but not accepted by #{obj_type.name}.#{field_name}|
-                  elsif arg_defn.type != object_field_arg.type
-                    field_errors << %|"#{arg_name}" is required by #{interface_type.name}.#{field_defn.name} to accept #{arg_defn.type} but #{obj_type.name}.#{field_name} accepts #{object_field_arg.type} for "#{arg_name}"|
-                  end
-                end
-
-                object_field.arguments.each do |arg_name, arg_defn|
-                  if field_defn.arguments[arg_name].nil? && arg_defn.type.is_a?(GraphQL::NonNullType)
-                    field_errors << %|"#{arg_name}" is not accepted by #{interface_type.name}.#{field_name} but required by #{obj_type.name}.#{field_name}|
-                  end
-                end
-              end
-            end
-          end
-          if field_errors.any?
-            "#{obj_type.name} failed to implement some interfaces: #{field_errors.join(", ")}"
-          else
-            nil
-          end
-        }
-      end
-
-      # A mapping of `{Class => [Proc, Proc...]}` pairs.
-      # To validate an instance, find entries where `object.is_a?(key)` is true.
-      # Then apply each rule from the matching values.
-      RULES = {
-        GraphQL::Field => [
-          Rules::NAME_IS_STRING,
-          Rules::RESERVED_NAME,
-          Rules::DESCRIPTION_IS_STRING_OR_NIL,
-          Rules.assert_property(:deprecation_reason, String, NilClass),
-          Rules.assert_property(:type, GraphQL::BaseType, GraphQL::Schema::LateBoundType),
-          Rules.assert_property(:property, Symbol, NilClass),
-          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
-          Rules::ARGUMENTS_ARE_VALID,
-        ],
-        GraphQL::Argument => [
-          Rules::NAME_IS_STRING,
-          Rules::RESERVED_NAME,
-          Rules::DESCRIPTION_IS_STRING_OR_NIL,
-          Rules::TYPE_IS_VALID_INPUT_TYPE,
-          Rules::DEFAULT_VALUE_IS_VALID_FOR_TYPE,
-        ],
-        GraphQL::BaseType => [
-          Rules::NAME_IS_STRING,
-          Rules::RESERVED_TYPE_NAME,
-          Rules::DESCRIPTION_IS_STRING_OR_NIL,
-        ],
-        GraphQL::ObjectType => [
-          Rules.assert_property_list_of(:interfaces, GraphQL::InterfaceType),
-          Rules::FIELDS_ARE_VALID,
-          Rules::INTERFACES_ARE_IMPLEMENTED,
-        ],
-        GraphQL::InputObjectType => [
-          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
-          Rules::ARGUMENTS_ARE_VALID,
-        ],
-        GraphQL::UnionType => [
-          Rules.assert_property_list_of(:possible_types, GraphQL::ObjectType),
-          Rules::HAS_ONE_OR_MORE_POSSIBLE_TYPES,
-        ],
-        GraphQL::InterfaceType => [
-          Rules::FIELDS_ARE_VALID,
-        ],
-        GraphQL::Schema => [
-          Rules::SCHEMA_INSTRUMENTERS_ARE_VALID,
-          Rules::SCHEMA_CAN_RESOLVE_TYPES,
-          Rules::SCHEMA_CAN_FETCH_IDS,
-          Rules::SCHEMA_CAN_GENERATE_IDS,
-        ],
-      }
-    end
-  end
-end

data/lib/graphql/static_validation/default_visitor.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module StaticValidation
-    class DefaultVisitor < BaseVisitor
-      include(GraphQL::StaticValidation::DefinitionDependencies)
-
-      StaticValidation::ALL_RULES.reverse_each do |r|
-        include(r)
-      end
-
-      include(GraphQL::InternalRepresentation::Rewrite)
-      include(ContextMethods)
-    end
-  end
-end

data/lib/graphql/static_validation/no_validate_visitor.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module StaticValidation
-    class NoValidateVisitor < StaticValidation::BaseVisitor
-      include(GraphQL::InternalRepresentation::Rewrite)
-      include(GraphQL::StaticValidation::DefinitionDependencies)
-      include(ContextMethods)
-    end
-  end
-end