graphql 1.9.5 → 1.13.19

data/lib/graphql/query/variables.rb

@@ -17,11 +17,15 @@ module GraphQL
         @provided_variables = GraphQL::Argument.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
           # If it's still nil, raise an error if it's required.
-          variable_type = schema.type_from_ast(ast_variable.type)
+          variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
           if variable_type.nil?
             # Pass -- it will get handled by a validator
           else
@@ -29,25 +33,40 @@ 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] = variable_type.coerce_input(provided_value, ctx)
+                  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
                 elsif default_value != nil
-                  # Add the variable if it wasn't provided but it has a default value (including `null`)
-                  memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                  memo[variable_name] = if ctx.interpreter?
+                    if default_value.is_a?(Language::Nodes::NullValue)
+                      nil
+                    else
+                      default_value
+                    end
+                  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)
+                  end
                 end
               end
-            rescue GraphQL::CoercionError, GraphQL::ExecutionError => ex
+            rescue GraphQL::ExecutionError => ex
               # TODO: This should really include the path to the problematic node in the variable value
               # 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?
@@ -58,6 +77,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

@@ -3,6 +3,7 @@ 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"
@@ -44,7 +45,12 @@ module GraphQL
 
     # @return [GraphQL::Language::Nodes::Document]
     def document
-      with_prepared_ast { @document }
+      # It's ok if this hasn't been assigned yet
+      if @query_string || @document
+        with_prepared_ast { @document }
+      else
+        nil
+      end
     end
 
     def inspect
@@ -73,19 +79,25 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    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: nil, max_complexity: nil, except: nil, only: nil)
+    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
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
       @operations = nil
       @validate = validate
-      # TODO: remove support for global tracers
-      @tracers = schema.tracers + GraphQL::Tracing.tracers + (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
         @tracers << GraphQL::Backtrace::Tracer
@@ -95,7 +107,7 @@ module GraphQL
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
       else
-        @provided_variables = variables
+        @provided_variables = variables || {}
       end
 
       @query_string = query_string || query
@@ -105,6 +117,10 @@ module GraphQL
         raise ArgumentError, "Query should only be provided a query string or a document, not both."
       end
 
+      if @query_string && !@query_string.is_a?(String)
+        raise ArgumentError, "Query string argument should be a String, got #{@query_string.class.name} instead."
+      end
+
       # A two-layer cache of type resolution:
       # { abstract_type => { value => resolved_type } }
       @resolved_types_cache = Hash.new do |h1, k1|
@@ -113,8 +129,6 @@ module GraphQL
         end
       end
 
-      @arguments_cache = ArgumentsCache.build(self)
-
       # Trying to execute a document
       # with no operations returns an empty hash
       @ast_variables = []
@@ -122,14 +136,13 @@ module GraphQL
       @operation_name = operation_name
       @prepared_ast = false
       @validation_pipeline = nil
-      @max_depth = max_depth || schema.max_depth
-      @max_complexity = max_complexity || schema.max_complexity
+      @max_depth = max_depth
+      @max_complexity = max_complexity
 
       @result_values = nil
       @executed = false
 
       # TODO add a general way to define schema-level filters
-      # TODO also add this to schema dumps
       if @schema.respond_to?(:visible?)
         merge_filters(only: @schema.method(:visible?))
       end
@@ -140,7 +153,11 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def_delegators :@schema, :interpreter?
+    def interpreter?
+      @interpreter
+    end
+
+    attr_accessor :multiplex
 
     def subscription_update?
       @subscription_topic && subscription?
@@ -152,7 +169,7 @@ module GraphQL
       @lookahead ||= begin
         ast_node = selected_operation
         root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        root_type = root_type.metadata[:type_class] || raise("Invariant: `lookahead` only works with class-based types")
+        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
@@ -182,13 +199,15 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self], context: @context)
-        }
+        Execution::Multiplex.run_queries(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end
 
+    def executed?
+      @executed
+    end
+
     def static_errors
       validation_errors + analysis_errors + context.errors
     end
@@ -229,10 +248,60 @@ module GraphQL
     end
 
     # Node-level cache for calculating arguments. Used during execution and query analysis.
-    # @api private
-    # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
-    def arguments_for(irep_or_ast_node, definition)
-      @arguments_cache[irep_or_ast_node][definition]
+    # @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
+    end
+
+    def arguments_cache
+      if interpreter?
+        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+      else
+        @arguments_cache ||= ArgumentsCache.build(self)
+      end
+    end
+
+    # A version of the given query string, with:
+    # - Variables inlined to the query
+    # - Strings replaced with `<REDACTED>`
+    # @return [String, nil] Returns nil if the query is invalid.
+    def sanitized_query_string(inline_variables: true)
+      with_prepared_ast {
+        schema.sanitized_printer.new(self, inline_variables: inline_variables).sanitized_query_string
+      }
+    end
+
+    # This contains a few components:
+    #
+    # - The selected operation name (or `anonymous`)
+    # - The fingerprint of the query string
+    # - The number of given variables (for readability)
+    # - The fingerprint of the given variables
+    #
+    # This fingerprint can be used to track runs of the same operation-variables combination over time.
+    #
+    # @see operation_fingerprint
+    # @see variables_fingerprint
+    # @return [String] An opaque hash identifying this operation-variables combination
+    def fingerprint
+      @fingerprint ||= "#{operation_fingerprint}/#{variables_fingerprint}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given query string and selected operation
+    def operation_fingerprint
+      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string)}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given a variable values (not including defaults)
+    def variables_fingerprint
+      @variables_fingerprint ||= "#{provided_variables.size}/#{Fingerprint.generate(provided_variables.to_json)}"
     end
 
     def validation_pipeline
@@ -291,6 +360,13 @@ module GraphQL
       with_prepared_ast { @subscription }
     end
 
+    # @api private
+    def with_error_handling
+      schema.error_handler.with_error_handling(context) do
+        yield
+      end
+    end
+
     private
 
     def find_operation(operations, operation_name)
@@ -305,8 +381,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden = GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
-
+      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string
@@ -359,11 +434,10 @@ 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,
-        max_complexity: @max_complexity || schema.max_complexity,
+        max_complexity: @max_complexity
       )
     end
 

data/lib/graphql/railtie.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
-
 module GraphQL
   class Railtie < Rails::Railtie
+    config.before_configuration do
+      # Bootsnap compile cache has similar expiration properties,
+      # so we assume that if the user has bootsnap setup it's ok
+      # to piggy back on it.
+      if ::Object.const_defined?("Bootsnap::CompileCache::ISeq") && Bootsnap::CompileCache::ISeq.cache_dir
+        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

data/lib/graphql/rake_task/validate.rb

@@ -7,6 +7,9 @@ module GraphQL
     desc "Get the checksum of a graphql-pro version and compare it to published versions on GitHub and graphql-ruby.org"
     task "graphql:pro:validate", [:gem_version] do |t, args|
       version = args[:gem_version]
+      if version.nil?
+        raise ArgumentError, "A specific version is required, eg `rake graphql:pro:validate[1.12.0]`"
+      end
       check = "\e[32m✓\e[0m"
       ex = "\e[31m✘\e[0m"
       puts "Validating graphql-pro v#{version}"

data/lib/graphql/rake_task.rb

@@ -76,15 +76,7 @@ module GraphQL
     # Set the parameters of this task by passing keyword arguments
     # or assigning attributes inside the block
     def initialize(options = {})
-      default_dependencies = if Rake::Task.task_defined?("environment")
-        [:environment]
-      else
-        []
-      end
-
-      all_options = DEFAULT_OPTIONS
-        .merge(dependencies: default_dependencies)
-        .merge(options)
+      all_options = DEFAULT_OPTIONS.merge(options)
       all_options.each do |k, v|
         self.public_send("#{k}=", v)
       end
@@ -106,6 +98,9 @@ module GraphQL
       result = schema.public_send(method_name, only: @only, except: @except, context: context)
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
+      if !result.end_with?("\n")
+        result += "\n"
+      end
       File.write(file, result)
     end
 
@@ -117,18 +112,26 @@ module GraphQL
       File.join(@directory, @json_outfile)
     end
 
+    def load_rails_environment_if_defined
+      if Rake::Task.task_defined?('environment')
+        Rake::Task['environment'].invoke
+      end
+    end
+
     # Use the Rake DSL to add tasks
     def define_task
       namespace(@namespace) do
         namespace("schema") do
           desc("Dump the schema to IDL in #{idl_path}")
           task :idl => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_definition, idl_path)
             puts "Schema IDL dumped into #{idl_path}"
           end
 
           desc("Dump the schema to JSON in #{json_path}")
           task :json => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_json, json_path)
             puts "Schema JSON dumped into #{json_path}"
           end

data/lib/graphql/relay/array_connection.rb

@@ -13,7 +13,7 @@ module GraphQL
           sliced_nodes.count > first
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && before
           # The original array is longer than the `before` index
-          index_from_cursor(before) < nodes.length
+          index_from_cursor(before) < nodes.length + 1
         else
           false
         end
@@ -31,24 +31,22 @@ module GraphQL
         end
       end
 
-      private
-
       def first
-        return @first if defined? @first
-
-        @first = get_limited_arg(:first)
-        @first = max_page_size if @first && max_page_size && @first > max_page_size
-        @first
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       def last
-        return @last if defined? @last
-
-        @last = get_limited_arg(:last)
-        @last = max_page_size if @last && max_page_size && @last > max_page_size
-        @last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
+      private
+
       # apply first / last limit results
       def paged_nodes
         @paged_nodes ||= begin

data/lib/graphql/relay/base_connection.rb

@@ -25,6 +25,10 @@ module GraphQL
         # @param nodes [Object] A collection of nodes (eg, Array, AR::Relation)
         # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
         def connection_for_nodes(nodes)
+          # If it's a new-style connection object, it's already ready to go
+          if nodes.is_a?(GraphQL::Pagination::Connection)
+            return nodes
+          end
           # Check for class _names_ because classes can be redefined in Rails development
           nodes.class.ancestors.each do |ancestor|
             conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
@@ -55,6 +59,13 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
+        GraphQL::Deprecation.warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+
+        deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
+        if deprecated_caller
+          GraphQL::Deprecation.warn "  -> called from #{deprecated_caller}"
+        end
+
         @context = context
         @nodes = nodes
         @arguments = arguments
@@ -70,14 +81,18 @@ module GraphQL
 
       def decode(data)
         @encoder.decode(data, nonce: true)
-      rescue ArgumentError
-        raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
       end
 
       # The value passed as `first:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def first
-        @first ||= get_limited_arg(:first)
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       # The value passed as `after:`, if there was one
@@ -89,7 +104,7 @@ module GraphQL
       # The value passed as `last:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def last
-        @last ||= get_limited_arg(:last)
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       # The value passed as `before:`, if there was one
@@ -139,7 +154,7 @@ module GraphQL
 
       # An opaque operation which returns a connection-specific cursor.
       def cursor_from_node(object)
-        raise NotImplementedError, "must return a cursor for this object/connection pair"
+        raise GraphQL::RequiredImplementationMissingError, "must return a cursor for this object/connection pair"
       end
 
       def inspect
@@ -148,24 +163,26 @@ module GraphQL
 
       private
 
-      # Return a sanitized `arguments[arg_name]` (don't allow negatives)
-      def get_limited_arg(arg_name)
-        arg_value = arguments[arg_name]
-        if arg_value.nil?
-          arg_value
-        elsif arg_value < 0
-          0
-        else
-          arg_value
+      # @param argument [nil, Integer] `first` or `last`, as provided by the client
+      # @param max_page_size [nil, Integer]
+      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      def limit_pagination_argument(argument, max_page_size)
+        if argument
+          if argument < 0
+            argument = 0
+          elsif max_page_size && argument > max_page_size
+            argument = max_page_size
+          end
         end
+        argument
       end
 
       def paged_nodes
-        raise NotImplementedError, "must return nodes for this connection after paging"
+        raise GraphQL::RequiredImplementationMissingError, "must return nodes for this connection after paging"
       end
 
       def sliced_nodes
-        raise NotImplementedError, "must return  all nodes for this connection after chopping off first and last"
+        raise GraphQL::RequiredImplementationMissingError, "must return  all nodes for this connection after chopping off first and last"
       end
     end
   end

data/lib/graphql/relay/connection_instrumentation.rb

@@ -10,10 +10,10 @@ module GraphQL
       def self.default_arguments
         @default_arguments ||= begin
           argument_definitions = [
-              ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
-              ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
-              ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
-              ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
+              ["first", GraphQL::DEPRECATED_INT_TYPE, "Returns the first _n_ elements from the list."],
+              ["after", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
+              ["last", GraphQL::DEPRECATED_INT_TYPE, "Returns the last _n_ elements from the list."],
+              ["before", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
             ]
 
           argument_definitions.reduce({}) do |memo, arg_defn|

data/lib/graphql/relay/connection_type.rb

@@ -1,25 +1,39 @@
 # frozen_string_literal: true
 module GraphQL
   module Relay
+    # @api deprecated
     module ConnectionType
       class << self
         # @return [Boolean] If true, connection types get a `nodes` shortcut field
-        attr_accessor :default_nodes_field
+        def default_nodes_field=(new_setting)
+          if new_setting
+            warn("GraphQL::Relay::ConnectionType will be removed in GraphQL 2.0.0; migrate to `GraphQL::Pagination::Connections` and remove this setting (`default_nodes_field = true`).")
+          end
+          @default_nodes_field = new_setting
+        end
+        attr_reader :default_nodes_field
+
         # @return [Boolean] If true, connections check for reverse-direction `has*Page` values
-        attr_accessor :bidirectional_pagination
+        def bidirectional_pagination=(new_setting)
+          if new_setting
+            warn("GraphQL::Relay::ConnectionType will be removed in GraphQL 2.0.0; migrate to `GraphQL::Pagination::Connections` and remove this setting (`bidirectional_pagination = true`).")
+          end
+          @bidirectional_pagination = new_setting
+        end
+        attr_reader :bidirectional_pagination
       end
 
       self.default_nodes_field = false
       self.bidirectional_pagination = false
 
-      # Create a connection which exposes edges of this type
+      # @api deprecated
       def self.create_type(wrapped_type, edge_type: nil, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
         custom_edge_class = edge_class
 
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
         # cyclical dependency errors :S
-        ObjectType.define do
+        ObjectType.deprecated_define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
           edge_type ||= wrapped_type.edge_type
           name("#{type_name}Connection")

data/lib/graphql/relay/edge_type.rb

@@ -2,6 +2,7 @@
 module GraphQL
   module Relay
     module EdgeType
+      # @api deprecated
       def self.create_type(wrapped_type, name: nil, &block)
         GraphQL::ObjectType.define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name

data/lib/graphql/relay/edges_instrumentation.rb

@@ -16,7 +16,6 @@ module GraphQL
         end
       end
 
-
       class EdgesResolve
         def initialize(edge_class:, resolve:)
           @edge_class = edge_class
@@ -31,7 +30,7 @@ module GraphQL
           if ctx.schema.lazy?(nodes)
             nodes
           else
-            nodes.map { |item| @edge_class.new(item, parent) }
+            nodes.map { |item| item.is_a?(GraphQL::Pagination::Connection::Edge) ? item : @edge_class.new(item, parent) }
           end
         end
       end

data/lib/graphql/relay/global_id_resolve.rb

@@ -10,8 +10,7 @@ module GraphQL
         if obj.is_a?(GraphQL::Schema::Object)
           obj = obj.object
         end
-        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition : @type
-        ctx.query.schema.id_from_object(obj, type, ctx)
+        ctx.query.schema.id_from_object(obj, @type, ctx)
       end
     end
   end