graphql 1.13.12 → 2.0.21

data/lib/graphql/query/validation_pipeline.rb

@@ -16,10 +16,8 @@ module GraphQL
     class ValidationPipeline
       attr_reader :max_depth, :max_complexity
 
-      def initialize(query:, validate:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
+      def initialize(query:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
-        @internal_representation = nil
-        @validate = validate
         @parse_error = parse_error
         @operation_name_error = operation_name_error
         @query = query
@@ -42,17 +40,15 @@ module GraphQL
         @validation_errors
       end
 
-      # @return [Hash<String, nil => GraphQL::InternalRepresentation::Node] Operation name -> Irep node pairs
-      def internal_representation
-        ensure_has_validated
-        @internal_representation
-      end
-
       def analyzers
         ensure_has_validated
         @query_analyzers
       end
 
+      def has_validated?
+        @has_validated == true
+      end
+
       private
 
       # If the pipeline wasn't run yet, run it.
@@ -63,7 +59,7 @@ module GraphQL
 
         if @parse_error
           # This is kind of crazy: we push the parse error into `ctx`
-          # in {DefaultParseError} so that users can _opt out_ by redefining that hook.
+          # in `def self.parse_error` by default so that users can _opt out_ by redefining that hook.
           # That means we can't _re-add_ the error here (otherwise we'd either
           # add it twice _or_ override the user's choice to not add it).
           # So we just have to know that it was invalid and go from there.
@@ -72,9 +68,8 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
+          validation_result = @schema.static_validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
-          @internal_representation = validation_result[:irep]
 
           if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
@@ -100,35 +95,15 @@ module GraphQL
       def build_analyzers(schema, max_depth, max_complexity)
         qa = schema.query_analyzers.dup
 
-        # Filter out the built in authorization analyzer.
-        # It is deprecated and does not have an AST analyzer alternative.
-        qa = qa.select do |analyzer|
-          if analyzer == GraphQL::Authorization::Analyzer && schema.using_ast_analysis?
-            raise "The Authorization analyzer is not supported with AST Analyzers"
-          else
-            true
-          end
-        end
-
         if max_depth || max_complexity
           # Depending on the analysis engine, we must use different analyzers
           # remove this once everything has switched over to AST analyzers
-          if schema.using_ast_analysis?
-            if max_depth
-              qa << GraphQL::Analysis::AST::MaxQueryDepth
-            end
-            if max_complexity
-              qa << GraphQL::Analysis::AST::MaxQueryComplexity
-            end
-          else
-            if max_depth
-              qa << GraphQL::Analysis::MaxQueryDepth.new(max_depth)
-            end
-            if max_complexity
-              qa << GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)
-            end
+          if max_depth
+            qa << GraphQL::Analysis::AST::MaxQueryDepth
+          end
+          if max_complexity
+            qa << GraphQL::Analysis::AST::MaxQueryComplexity
           end
-
           qa
         else
           qa

data/lib/graphql/query/variable_validation_error.rb

@@ -4,11 +4,11 @@ module GraphQL
     class VariableValidationError < GraphQL::ExecutionError
       attr_accessor :value, :validation_result
 
-      def initialize(variable_ast, type, value, validation_result)
+      def initialize(variable_ast, type, value, validation_result, msg: nil)
         @value = value
         @validation_result = validation_result
 
-        msg = "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
+        msg ||= "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
 
         if problem_fields.any?
           msg += " for #{problem_fields.join(", ")}"

data/lib/graphql/query/variables.rb

@@ -14,9 +14,13 @@ module GraphQL
         schema = ctx.schema
         @context = ctx
 
-        @provided_variables = GraphQL::Argument.deep_stringify(provided_variables)
+        @provided_variables = deep_stringify(provided_variables)
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
+          if schema.validate_max_errors && schema.validate_max_errors <= @errors.count
+            add_max_errors_reached_message
+            break
+          end
           # Find the right value for this variable:
           # - First, use the value provided at runtime
           # - Then, fall back to the default value from the query string
@@ -29,30 +33,18 @@ module GraphQL
             default_value = ast_variable.default_value
             provided_value = @provided_variables[variable_name]
             value_was_provided =  @provided_variables.key?(variable_name)
+            max_errors = schema.validate_max_errors - @errors.count if schema.validate_max_errors
             begin
-              validation_result = variable_type.validate_input(provided_value, ctx)
+              validation_result = variable_type.validate_input(provided_value, ctx, max_errors: max_errors)
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = if ctx.interpreter?
-                    provided_value
-                  elsif provided_value.nil?
-                    nil
-                  else
-                    schema.error_handler.with_error_handling(context) do
-                      variable_type.coerce_input(provided_value, ctx)
-                    end
-                  end
+                  memo[variable_name] = provided_value
                 elsif default_value != nil
-                  memo[variable_name] = if ctx.interpreter?
-                    if default_value.is_a?(Language::Nodes::NullValue)
-                      nil
-                    else
-                      default_value
-                    end
+                  memo[variable_name] = if default_value.is_a?(Language::Nodes::NullValue)
+                    nil
                   else
-                    # Add the variable if it wasn't provided but it has a default value (including `null`)
-                    GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                    default_value
                   end
                 end
               end
@@ -61,8 +53,7 @@ module GraphQL
               # like InputValidationResults generated by validate_non_null_input but unfortunately we don't
               # have this information available in the coerce_input call chain. Note this path is the path
               # that appears under errors.extensions.problems.path and NOT the result path under errors.path.
-              validation_result = GraphQL::Query::InputValidationResult.new
-              validation_result.add_problem(ex.message)
+              validation_result = GraphQL::Query::InputValidationResult.from_problem(ex.message)
             end
 
             if !validation_result.valid?
@@ -73,6 +64,29 @@ module GraphQL
       end
 
       def_delegators :@storage, :length, :key?, :[], :fetch, :to_h
+
+      private
+
+      def deep_stringify(val)
+        case val
+        when Array
+          val.map { |v| deep_stringify(v) }
+        when Hash
+          new_val = {}
+          val.each do |k, v|
+            new_val[k.to_s] = deep_stringify(v)
+          end
+          new_val
+        else
+          val
+        end
+      end    
+
+      def add_max_errors_reached_message
+        message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
+        validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
+        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message) 
+      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
-require "graphql/query/arguments"
-require "graphql/query/arguments_cache"
 require "graphql/query/context"
-require "graphql/query/executor"
 require "graphql/query/fingerprint"
-require "graphql/query/literal_input"
 require "graphql/query/null_context"
 require "graphql/query/result"
-require "graphql/query/serial_execution"
 require "graphql/query/variables"
 require "graphql/query/input_validation_result"
 require "graphql/query/variable_validation_error"
@@ -39,7 +34,16 @@ module GraphQL
     attr_accessor :operation_name
 
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
-    attr_accessor :validate
+    attr_reader :validate
+
+    # @param new_validate [Boolean] if false, static validation is skipped. This can't be reasssigned after validation.
+    def validate=(new_validate)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#validate= after validation has run, remove this assignment."
+      else
+        @validate = new_validate
+      end
+    end
 
     attr_writer :query_string
 
@@ -82,13 +86,7 @@ module GraphQL
     def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
-
-      # Use the `.graphql_definition` here which will return legacy types instead of classes
-      if schema.is_a?(Class) && !schema.interpreter?
-        schema = schema.graphql_definition
-      end
       @schema = schema
-      @interpreter = @schema.interpreter?
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
@@ -97,12 +95,24 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
-      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
+      context_tracers = (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + context_tracers
+
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        @tracers << GraphQL::Backtrace::Tracer
+        if schema.trace_class <= GraphQL::Tracing::LegacyTrace
+          context_tracers += [GraphQL::Backtrace::Tracer]
+          @tracers << GraphQL::Backtrace::Tracer
+        elsif !(current_trace.class <= GraphQL::Backtrace::Trace)
+          raise "Invariant: `backtrace: true` should have provided a trace class with Backtrace mixed in, but it didnt. (Found: #{current_trace.class.ancestors}). This is a bug in GraphQL-Ruby, please report it on GitHub."
+        end
+      end
+
+      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
+        raise ArgumentError, "context[:tracers] are not supported without `trace_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
       end
 
+
       @analysis_errors = []
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
@@ -154,11 +164,16 @@ module GraphQL
     end
 
     def interpreter?
-      @interpreter
+      true
     end
 
     attr_accessor :multiplex
 
+    # @return [GraphQL::Tracing::Trace]
+    def current_trace
+      @current_trace ||= multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self)
+    end
+
     def subscription_update?
       @subscription_topic && subscription?
     end
@@ -169,7 +184,6 @@ module GraphQL
       @lookahead ||= begin
         ast_node = selected_operation
         root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        root_type = root_type.type_class || raise("Invariant: `lookahead` only works with class-based types")
         GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
       end
     end
@@ -199,7 +213,7 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        Execution::Multiplex.run_queries(@schema, [self], context: @context)
+        Execution::Interpreter.run_all(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end
@@ -237,35 +251,17 @@ module GraphQL
       end
     end
 
-    def irep_selection
-      @selection ||= begin
-        if selected_operation && internal_representation
-          internal_representation.operation_definitions[selected_operation.name]
-        else
-          nil
-        end
-      end
-    end
-
     # Node-level cache for calculating arguments. Used during execution and query analysis.
     # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
     # @param definition [GraphQL::Schema::Field]
     # @param parent_object [GraphQL::Schema::Object]
     # @return Hash{Symbol => Object}
     def arguments_for(ast_node, definition, parent_object: nil)
-      if interpreter?
-        arguments_cache.fetch(ast_node, definition, parent_object)
-      else
-        arguments_cache[ast_node][definition]
-      end
+      arguments_cache.fetch(ast_node, definition, parent_object)
     end
 
     def arguments_cache
-      if interpreter?
-        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-      else
-        @arguments_cache ||= ArgumentsCache.build(self)
-      end
+      @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
     end
 
     # A version of the given query string, with:
@@ -308,7 +304,7 @@ module GraphQL
       with_prepared_ast { @validation_pipeline }
     end
 
-    def_delegators :validation_pipeline, :validation_errors, :internal_representation,
+    def_delegators :validation_pipeline, :validation_errors,
                    :analyzers, :ast_analyzers, :max_depth, :max_complexity
 
     attr_accessor :analysis_errors
@@ -326,8 +322,8 @@ module GraphQL
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}
     # @see {#possible_types} to apply filtering from `only` / `except`
-    def resolve_type(abstract_type, value = :__undefined__)
-      if value.is_a?(Symbol) && value == :__undefined__
+    def resolve_type(abstract_type, value = NOT_CONFIGURED)
+      if value.is_a?(Symbol) && value == NOT_CONFIGURED
         # Old method signature
         value = abstract_type
         abstract_type = nil
@@ -361,10 +357,8 @@ module GraphQL
     end
 
     # @api private
-    def with_error_handling
-      schema.error_handler.with_error_handling(context) do
-        yield
-      end
+    def handle_or_reraise(err)
+      schema.handle_or_reraise(context, err)
     end
 
     private
@@ -385,7 +379,7 @@ module GraphQL
       parse_error = nil
       @document ||= begin
         if query_string
-          GraphQL.parse(query_string, tracer: self)
+          GraphQL.parse(query_string, trace: self.current_trace)
         end
       rescue GraphQL::ParseError => err
         parse_error = err
@@ -434,7 +428,6 @@ module GraphQL
 
       @validation_pipeline = GraphQL::Query::ValidationPipeline.new(
         query: self,
-        validate: @validate,
         parse_error: parse_error,
         operation_name_error: operation_name_error,
         max_depth: @max_depth,

data/lib/graphql/railtie.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module GraphQL
   class Railtie < Rails::Railtie
     config.before_configuration do
@@ -10,108 +9,5 @@ module GraphQL
         Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
       end
     end
-
-    rake_tasks do
-      # Defer this so that you only need the `parser` gem when you _run_ the upgrader
-      def load_upgraders
-        require_relative './upgrader/member'
-        require_relative './upgrader/schema'
-      end
-
-      namespace :graphql do
-        task :upgrade, [:dir] do |t, args|
-          unless (dir = args[:dir])
-            fail 'You have to give me a directory where your GraphQL schema and types live. ' \
-             'For example: `bin/rake graphql:upgrade[app/graphql/**/*]`'
-          end
-
-          Dir[dir].each do |file|
-            # Members (types, interfaces, etc.)
-            if file =~ /.*_(type|interface|enum|union|)\.rb$/
-              Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
-            end
-          end
-
-          puts "Upgrade complete! Note that this is a best-effort approach, and may very well contain some bugs."
-          puts "Don't forget to create the base objects. For example, you could run:"
-          puts "\tbin/rake graphql:upgrade:create_base_objects[app/graphql]"
-        end
-
-        namespace :upgrade do
-          task :create_base_objects, [:base_dir] do |t, args|
-            unless (base_dir = args[:base_dir])
-              fail 'You have to give me a directory where your GraphQL types live. ' \
-                   'For example: `bin/rake graphql:upgrade:create_base_objects[app/graphql]`'
-            end
-
-            destination_file = File.join(base_dir, "types", "base_scalar.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_input_object.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_enum.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_union.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseUnion < GraphQL::Schema::Union\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_interface.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_object.rb")
-            unless File.exists?(destination_file)
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseObject < GraphQL::Schema::Object\nend"
-              end
-            end
-          end
-
-          task :schema, [:schema_file] do |t, args|
-            schema_file = args.schema_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Schema.new File.read(schema_file)
-
-            puts "- Transforming schema #{schema_file}"
-            File.open(schema_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-
-          task :member, [:member_file] do |t, args|
-            member_file = args.member_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Member.new File.read(member_file)
-            next unless upgrader.upgradeable?
-
-            puts "- Transforming member #{member_file}"
-            File.open(member_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-        end
-      end
-    end
   end
 end

data/lib/graphql/rake_task/validate.rb

@@ -15,7 +15,7 @@ module GraphQL
       puts "Validating graphql-pro v#{version}"
       puts "  - Checking for graphql-pro credentials..."
 
-      creds = `bundle config gems.graphql.pro`[/[a-z0-9]{11}:[a-z0-9]{11}/]
+      creds = `bundle config gems.graphql.pro --parseable`[/[a-z0-9]{11}:[a-z0-9]{11}/]
       if creds.nil?
         puts "    #{ex} failed, please set with `bundle config gems.graphql.pro $MY_CREDENTIALS`"
         exit(1)

data/lib/graphql/rake_task.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "fileutils"
+require "rake"
 require "graphql/rake_task/validate"
 
 module GraphQL
@@ -22,6 +23,10 @@ module GraphQL
   # @example Invoking the task from Ruby
   #   require "rake"
   #   Rake::Task["graphql:schema:dump"].invoke
+  #
+  # @example Providing arguments to build the introspection query
+  #   require "graphql/rake_task"
+  #   GraphQL::RakeTask.new(schema_name: "MySchema", include_is_one_of: true)
   class RakeTask
     include Rake::DSL
 
@@ -36,6 +41,11 @@ module GraphQL
       directory: ".",
       idl_outfile: "schema.graphql",
       json_outfile: "schema.json",
+      include_deprecated_args: true,
+      include_schema_description: false,
+      include_is_repeatable: false,
+      include_specified_by_url: false,
+      include_is_one_of: false
     }
 
     # @return [String] Namespace for generated tasks
@@ -73,6 +83,10 @@ module GraphQL
     # @return [String] directory for IDL & JSON files
     attr_accessor :directory
 
+    # @return [Boolean] Options for additional fields in the introspection query JSON response
+    # @see GraphQL::Schema.as_json
+    attr_accessor :include_deprecated_args, :include_schema_description, :include_is_repeatable, :include_specified_by_url, :include_is_one_of
+
     # Set the parameters of this task by passing keyword arguments
     # or assigning attributes inside the block
     def initialize(options = {})
@@ -95,7 +109,21 @@ module GraphQL
     def write_outfile(method_name, file)
       schema = @load_schema.call(self)
       context = @load_context.call(self)
-      result = schema.public_send(method_name, only: @only, except: @except, context: context)
+      result = case method_name
+      when :to_json
+        schema.to_json(
+          include_is_one_of: include_is_one_of,
+          include_deprecated_args: include_deprecated_args,
+          include_is_repeatable: include_is_repeatable,
+          include_specified_by_url: include_specified_by_url,
+          include_schema_description: include_schema_description,
+          only: @only, except: @except, context: context
+        )
+      when :to_definition
+        schema.to_definition(only: @only, except: @except, context: context)
+      else
+        raise ArgumentError, "Unexpected schema dump method: #{method_name.inspect}"
+      end
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
       if !result.end_with?("\n")

data/lib/graphql/relay/range_add.rb

@@ -31,29 +31,18 @@ module GraphQL
 
       # @param collection [Object] The list of items to wrap in a connection
       # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
+      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection
       # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
-      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
       # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
-      def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
-        if context.nil?
-          caller_loc = caller(2, 1).first
-          GraphQL::Deprecation.warn("`context: ...` will be required by `RangeAdd.new` in GraphQL-Ruby 2.0. Add `context: context` to the call at #{caller_loc}.")
-        end
-        if context && context.schema.new_connections?
-          conn_class = context.schema.connections.wrapper_for(collection)
-          # The rest will be added by ConnectionExtension
-          @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
-          # Check if this connection supports it, to support old versions of GraphQL-Pro
-          @edge = if @connection.respond_to?(:range_add_edge)
-            @connection.range_add_edge(item)
-          else
-            @connection.edge_class.new(item, @connection)
-          end
+      def initialize(collection:, item:, context:, parent: nil, edge_class: nil)
+        conn_class = context.schema.connections.wrapper_for(collection)
+        # The rest will be added by ConnectionExtension
+        @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
+        # Check if this connection supports it, to support old versions of GraphQL-Pro
+        @edge = if @connection.respond_to?(:range_add_edge)
+          @connection.range_add_edge(item)
         else
-          connection_class = BaseConnection.connection_for_nodes(collection)
-          @connection = connection_class.new(collection, {}, parent: parent, context: context)
-          edge_class ||= Relay::Edge
-          @edge = edge_class.new(item, @connection)
+          @connection.edge_class.new(item, @connection)
         end
 
         @parent = parent

data/lib/graphql/relay.rb

@@ -1,18 +1,3 @@
 # frozen_string_literal: true
 
-require 'graphql/relay/page_info'
-require 'graphql/relay/edge'
-require 'graphql/relay/edge_type'
-require 'graphql/relay/edges_instrumentation'
-require 'graphql/relay/base_connection'
-require 'graphql/relay/array_connection'
 require 'graphql/relay/range_add'
-require 'graphql/relay/relation_connection'
-require 'graphql/relay/mongo_relation_connection'
-require 'graphql/relay/global_id_resolve'
-require 'graphql/relay/mutation'
-require 'graphql/relay/node'
-require 'graphql/relay/connection_instrumentation'
-require 'graphql/relay/connection_resolve'
-require 'graphql/relay/connection_type'
-require 'graphql/relay/type_extensions'

data/lib/graphql/schema/addition.rb

@@ -107,6 +107,11 @@ module GraphQL
               if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
+              int.interfaces.each do |indirect_int|
+                if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name))
+                  update_type_owner(owner, indirect_int_type)
+                end
+              end
             end
           end
         when nil
@@ -136,14 +141,7 @@ module GraphQL
       end
 
       def add_type(type, owner:, late_types:, path:)
-        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
-          type_class = type.metadata[:type_class]
-          if type_class.nil?
-            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
-          else
-            type = type_class
-          end
-        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+        if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
           late_types << [owner, type]
           return
         end
@@ -153,7 +151,7 @@ module GraphQL
           um << owner
         end
 
-        if (prev_type = get_local_type(type.graphql_name)) && prev_type == type
+        if (prev_type = get_local_type(type.graphql_name)) && (prev_type == type || (prev_type.is_a?(Array) && prev_type.include?(type)))
           # No need to re-visit
         elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
           @directives << type