graphql 2.5.22 → 2.5.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 453860aab49f87d8b8771b00cc50b34a4567e7c80d7ce15b95c1b4fa82b23286
-  data.tar.gz: f33d534cbbccfcfb89ba8e6f553ea17d71199ca3fc898ab75c5f3ace08aba820
+  metadata.gz: 724e526bb33dee5a8b39cb04b4d42f2e969e45aafe73581c5bdd02177cfa1347
+  data.tar.gz: f211ca87d49c5077b0ae4744ce5956795835a6405a07e8782970cde14d172d7e
 SHA512:
-  metadata.gz: 3c2c8b87e60b9312ce5fb3848cb9a8112b6d050b6ee9c31eee5720932a2cf754f97f6f7bef273b491199aaa46c7551348e07294270585e79a1e35d176126bdfb
-  data.tar.gz: b679a8434d195d513f97963b2fe70b296cb2106ceda4ae2b7c756d1127d8ee4c56f2e3106b4a01c609498904622ada5d569f489bf97a13f8627e7b6a6a1d83fd
+  metadata.gz: 5d9c249f5d7bbe3ef06070cf52b04586eedf2df06f7c1fc95c6ab47bdc8182218fff2281d76a3f2a18bef4f1ad9c508901e6c7a3f882d28390afdd2f4dca6fd0
+  data.tar.gz: 5179a34bc5c34769021fab1dff6384c22f73f776dc994a82f9bce635ddf6ead05ec0a3d2ff37bfcedbc892d87d2d7a82b08eab4e4cf319ee390e2c5a34db76fa

data/lib/graphql/execution/interpreter/runtime.rb

@@ -603,7 +603,7 @@ module GraphQL
                 err
               end
               continue_value(next_value, field, is_non_null, ast_node, result_name, selection_result)
-            elsif GraphQL::Execution::SKIP == value
+            elsif value.is_a?(GraphQL::Execution::Skip)
               # It's possible a lazy was already written here
               case selection_result
               when GraphQLResultHash
@@ -761,7 +761,7 @@ module GraphQL
                   idx += 1
                   if use_dataloader_job
                     @dataloader.append_job do
-                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
+                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, nil)
                     end
                   else
                     resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
@@ -803,6 +803,7 @@ module GraphQL
         end
 
         def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
+          runtime_state ||= get_current_runtime_state
           runtime_state.current_result_name = this_idx
           runtime_state.current_result = response_list
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do

data/lib/graphql/execution/interpreter.rb

@@ -58,11 +58,6 @@ module GraphQL
               # Do as much eager evaluation of the query as possible
               results = []
               queries.each_with_index do |query, idx|
-                if query.subscription? && !query.subscription_update?
-                  subs_namespace = query.context.namespace(:subscriptions)
-                  subs_namespace[:events] = []
-                  subs_namespace[:subscriptions] = {}
-                end
                 multiplex.dataloader.append_job {
                   operation = query.selected_operation
                   result = if operation.nil? || !query.valid? || !query.context.errors.empty?
@@ -74,7 +69,9 @@ module GraphQL
                       # in particular, assign it here:
                       runtime = Runtime.new(query: query)
                       query.context.namespace(:interpreter_runtime)[:runtime] = runtime
-
+                      if query.subscription? && !query.subscription_update?
+                        schema.subscriptions.initialize_subscriptions(query)
+                      end
                       query.current_trace.execute_query(query: query) do
                         runtime.run_eager
                       end
@@ -91,9 +88,6 @@ module GraphQL
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|
                 query = queries[idx]
-                if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
-                  schema.subscriptions.write_subscription(query, events)
-                end
                 # Assign the result so that it can be accessed in instrumentation
                 query.result_values = if data_result.equal?(NO_OPERATION)
                   if !query.valid? || !query.context.errors.empty?
@@ -103,6 +97,9 @@ module GraphQL
                     data_result
                   end
                 else
+                  if query.subscription?
+                    schema.subscriptions.finish_subscriptions(query)
+                  end
                   result = {}
 
                   if !query.context.errors.empty?

data/lib/graphql/execution/lazy.rb

@@ -38,7 +38,7 @@ module GraphQL
         # (fewer clauses in a hot `case` block), but now it requires special handling here.
         # I think it's still worth it for the performance win, but if the number of special
         # cases grows, then maybe it's worth rethinking somehow.
-        if @value.is_a?(StandardError) && @value != GraphQL::Execution::SKIP
+        if @value.is_a?(StandardError) && !@value.is_a?(GraphQL::Execution::Skip)
           raise @value
         else
           @value

data/lib/graphql/execution/next/field_resolve_step.rb

@@ -48,59 +48,86 @@ module GraphQL
           nil
         end
 
-        def coerce_arguments(argument_owner, ast_arguments_or_hash)
-          arg_defns = argument_owner.arguments(@selections_step.query.context)
+        def coerce_arguments(argument_owner, ast_arguments_or_hash, run_loads = true)
+          arg_defns = @selections_step.query.types.arguments(argument_owner)
           if arg_defns.empty?
             return EmptyObjects::EMPTY_HASH
           end
           args_hash = {}
-          if ast_arguments_or_hash.is_a?(Hash)
-            ast_arguments_or_hash.each do |key, value|
-              key_s = nil
-              arg_defn = arg_defns.each_value.find { |a|
-                a.keyword == key || a.graphql_name == (key_s ||= String(key))
-              }
-              coerce_argument_value(args_hash, arg_defn, value)
-            end
-          else
-            ast_arguments_or_hash.each { |arg_node|
-              arg_defn = arg_defns[arg_node.name]
-              coerce_argument_value(args_hash, arg_defn, arg_node.value)
-            }
+
+          if ast_arguments_or_hash.nil? # This can happen with `.trigger`
+            return args_hash
           end
-          # TODO refactor the loop above into this one
-          arg_defns.each do |arg_graphql_name, arg_defn|
-            if arg_defn.default_value? && !args_hash.key?(arg_defn.keyword)
-              coerce_argument_value(args_hash, arg_defn, arg_defn.default_value)
+
+          arg_inputs_are_h = ast_arguments_or_hash.is_a?(Hash)
+
+          arg_defns.each do |arg_defn|
+            arg_value = nil
+            was_found = false
+            if arg_inputs_are_h
+              ast_arguments_or_hash.each do |key, value|
+                if key == arg_defn.keyword || key.to_s == arg_defn.graphql_name
+                  arg_value = value
+                  was_found = true
+                  break
+                end
+              end
+            else
+              ast_arguments_or_hash.each do |arg_node|
+                if arg_node.name == arg_defn.graphql_name
+                  arg_value = arg_node.value
+                  was_found = true
+                  break
+                end
+              end
+            end
+
+            if arg_value.is_a?(Language::Nodes::VariableIdentifier)
+              vars = @selections_step.query.variables
+              arg_value = if vars.key?(arg_value.name)
+                vars[arg_value.name]
+              elsif vars.key?(arg_value.name.to_sym)
+                vars[arg_value.name.to_sym]
+              else
+                was_found = false
+                nil
+              end
+            end
+
+            if !was_found && arg_defn.default_value?
+              was_found = true
+              arg_value = arg_defn.default_value
+            end
+
+            if was_found
+              coerce_argument_value(args_hash, arg_defn, arg_value, run_loads)
             end
           end
 
           args_hash
         end
 
-        def coerce_argument_value(arguments, arg_defn, arg_value, target_keyword: arg_defn.keyword, as_type: nil)
+        def coerce_argument_value(arguments, arg_defn, arg_value, run_loads, target_keyword: run_loads ? arg_defn.keyword : arg_defn.graphql_name, as_type: nil)
           arg_t = as_type || arg_defn.type
           if arg_t.non_null?
             arg_t = arg_t.of_type
           end
 
-          arg_value = if arg_value.is_a?(Language::Nodes::VariableIdentifier)
+          if arg_value.is_a?(Language::Nodes::VariableIdentifier)
             vars = @selections_step.query.variables
-            if vars.key?(arg_value.name)
+            arg_value = if vars.key?(arg_value.name)
               vars[arg_value.name]
             elsif vars.key?(arg_value.name.to_sym)
               vars[arg_value.name.to_sym]
             else
-              return # not present
+              nil
             end
-          elsif arg_value.is_a?(Language::Nodes::NullValue)
-            nil
+          end
+
+          if arg_value.is_a?(Language::Nodes::NullValue)
+            arg_value = nil
           elsif arg_value.is_a?(Language::Nodes::Enum)
-            arg_value.name
-          elsif arg_value.is_a?(Language::Nodes::InputObject)
-            arg_value.arguments # rubocop:disable Development/ContextIsPassedCop
-          else
-            arg_value
+            arg_value = arg_value.name
           end
 
           ctx = @selections_step.query.context
@@ -111,7 +138,7 @@ module GraphQL
               arg_value = Array(arg_value)
               inner_t = arg_t.of_type
               result = Array.new(arg_value.size)
-              arg_value.each_with_index { |v, i| coerce_argument_value(result, arg_defn, v, target_keyword: i, as_type: inner_t) }
+              arg_value.each_with_index { |v, i| coerce_argument_value(result, arg_defn, v, run_loads, target_keyword: i, as_type: inner_t) }
               result
             end
           elsif arg_t.kind.leaf?
@@ -125,7 +152,8 @@ module GraphQL
               end
             end
           elsif arg_t.kind.input_object?
-            input_obj_args = coerce_arguments(arg_t, arg_value)
+            input_obj_vals = arg_value.is_a?(Language::Nodes::InputObject) ? arg_value.arguments : arg_value # rubocop:disable Development/ContextIsPassedCop
+            input_obj_args = coerce_arguments(arg_t, input_obj_vals)
             arg_t.new(nil, ruby_kwargs: input_obj_args, context: @selections_step.query.context, defaults_used: nil)
           else
             raise "Unsupported argument value: #{arg_t.to_type_signature} / #{arg_value.class} (#{arg_value.inspect})"
@@ -145,7 +173,7 @@ module GraphQL
 
           if arg_value.is_a?(GraphQL::Error)
             @arguments = arg_value
-          elsif arg_defn.loads && as_type.nil? && !arg_value.nil?
+          elsif run_loads && arg_defn.loads && as_type.nil? && !arg_value.nil?
             # This is for legacy compat:
             load_receiver = if (r = @field_definition.resolver)
               r.new(field: @field_definition, context: @selections_step.query.context, object: nil)
@@ -252,18 +280,11 @@ module GraphQL
           query = @selections_step.query
           field_name = @ast_node.name
           @field_definition = query.get_field(@parent_type, field_name) || raise("Invariant: no field found for #{@parent_type.to_type_signature}.#{ast_node.name}")
-          if field_name == "__typename"
-            # TODO handle custom introspection
-            @field_results = Array.new(@selections_step.objects.size, @parent_type.graphql_name)
-            @object_is_authorized = AlwaysAuthorized
-            build_results
-            return
-          end
-
           arguments = coerce_arguments(@field_definition, @ast_node.arguments) # rubocop:disable Development/ContextIsPassedCop
           @arguments ||= arguments # may have already been set to an error
 
-          if @pending_steps.nil? || @pending_steps.size == 0
+          if (@pending_steps.nil? || @pending_steps.size == 0) &&
+              @field_results.nil? # Make sure the arguments flow didn't already call through
             execute_field
           end
         end
@@ -323,6 +344,14 @@ module GraphQL
               is_authed = @field_definition.authorized?(o, @arguments, ctx)
               if is_authed
                 authorized_objects << o
+              else
+                begin
+                  err = GraphQL::UnauthorizedFieldError.new(object: o, type: @parent_type, context: ctx, field: @field_definition)
+                  authorized_objects << query.schema.unauthorized_object(err)
+                  is_authed = true
+                rescue GraphQL::ExecutionError => exec_err
+                  add_graphql_error(exec_err)
+                end
               end
               is_authed
             }
@@ -616,29 +645,35 @@ module GraphQL
           method_receiver = @field_definition.dynamic_introspection ? @field_definition.owner : @parent_type
           case @field_definition.execution_next_mode
           when :resolve_batch
-            if args_hash.empty?
-              method_receiver.public_send(@field_definition.execution_next_mode_key, objects, context)
-            else
+            begin
               method_receiver.public_send(@field_definition.execution_next_mode_key, objects, context, **args_hash)
+            rescue GraphQL::ExecutionError => exec_err
+              Array.new(objects.size, exec_err)
             end
           when :resolve_static
-            result = if args_hash.empty?
-              method_receiver.public_send(@field_definition.execution_next_mode_key, context)
-            else
-              method_receiver.public_send(@field_definition.execution_next_mode_key, context, **args_hash)
-            end
+            result = method_receiver.public_send(@field_definition.execution_next_mode_key, context, **args_hash)
             Array.new(objects.size, result)
           when :resolve_each
-            if args_hash.empty?
-              objects.map { |o| method_receiver.public_send(@field_definition.execution_next_mode_key, o, context) }
-            else
-              objects.map { |o| method_receiver.public_send(@field_definition.execution_next_mode_key, o, context, **args_hash) }
+            objects.map do |o|
+              method_receiver.public_send(@field_definition.execution_next_mode_key, o, context, **args_hash)
+            rescue GraphQL::ExecutionError => err
+              err
             end
           when :hash_key
             objects.map { |o| o[@field_definition.execution_next_mode_key] }
           when :direct_send
             if args_hash.empty?
-              objects.map { |o| o.public_send(@field_definition.execution_next_mode_key) }
+              objects.map do |o|
+                o.public_send(@field_definition.execution_next_mode_key)
+              rescue GraphQL::ExecutionError => err
+                err
+              rescue StandardError => stderr
+                begin
+                  @selections_step.query.handle_or_reraise(stderr)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
+              end
             else
               objects.map { |o| o.public_send(@field_definition.execution_next_mode_key, **args_hash) }
             end
@@ -684,17 +719,14 @@ module GraphQL
               if @field_definition.dynamic_introspection
                 obj_inst = @owner.wrap(obj_inst, context)
               end
-              if args_hash.empty?
-                obj_inst.public_send(@field_definition.execution_next_mode_key)
-              else
-                obj_inst.public_send(@field_definition.execution_next_mode_key, **args_hash)
-              end
+              obj_inst.public_send(@field_definition.execution_next_mode_key, **args_hash)
+            rescue GraphQL::ExecutionError => exec_err
+              exec_err
             end
           else
             raise "Batching execution for #{path} not implemented (execution_next_mode: #{@execution_next_mode.inspect}); provide `resolve_static:`, `resolve_batch:`, `hash_key:`, `method:`, or use a compatibility plug-in"
           end
         end
-
       end
 
       class RawValueFieldResolveStep < FieldResolveStep

data/lib/graphql/execution/next/load_argument_step.rb

@@ -20,7 +20,11 @@ module GraphQL
 
         def call
           context = @field_resolve_step.selections_step.query.context
-          @loaded_value = @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
+          @loaded_value = begin
+            @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
+          rescue GraphQL::UnauthorizedError => auth_err
+            context.schema.unauthorized_object(auth_err)
+          end
           if (runner = @field_resolve_step.runner).resolves_lazies && runner.lazy?(@loaded_value)
             runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
           else

data/lib/graphql/execution/next/prepare_object_step.rb

@@ -72,7 +72,7 @@ module GraphQL
           begin
             query.current_trace.begin_authorized(@resolved_type, @object, query.context)
             @authorized_value = @resolved_type.authorized?(@object, query.context)
-            query.current_trace.end_authorized(@resolve_type, @object, query.context, @authorized_value)
+            query.current_trace.end_authorized(@resolved_type, @object, query.context, @authorized_value)
           rescue GraphQL::UnauthorizedError => auth_err
             @authorization_error = auth_err
           end
@@ -83,7 +83,7 @@ module GraphQL
           else
             create_result
           end
-        rescue GraphQL::Error => err
+        rescue GraphQL::RuntimeError => err
           @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
         end
 

data/lib/graphql/execution/next/runner.rb

@@ -23,9 +23,9 @@ module GraphQL
         end
 
         def resolve_type(type, object, query)
-          query.current_trace.begin_resolve_type(@static_type, object, query.context)
+          query.current_trace.begin_resolve_type(type, object, query.context)
           resolved_type, _ignored_new_value = query.resolve_type(type, object)
-          query.current_trace.end_resolve_type(@static_type, object, query.context, resolved_type)
+          query.current_trace.end_resolve_type(type, object, query.context, resolved_type)
           resolved_type
         end
 
@@ -140,7 +140,18 @@ module GraphQL
                   )]
                 end
               when "subscription"
-                raise ArgumentError, "TODO implement subscriptions"
+                if !query.subscription_update?
+                  schema.subscriptions.initialize_subscriptions(query)
+                end
+                isolated_steps[0] << SelectionsStep.new(
+                  parent_type: root_type,
+                  selections: selected_operation.selections,
+                  objects: [root_value],
+                  results: [data],
+                  path: EmptyObjects::EMPTY_ARRAY,
+                  runner: self,
+                  query: query,
+                )
               else
                 raise ArgumentError, "Unhandled operation type: #{operation.operation_type.inspect}"
               end
@@ -165,6 +176,10 @@ module GraphQL
 
             queries.each_with_index.map do |query, idx|
               result = results[idx]
+              if query.subscription?
+                @schema.subscriptions.finish_subscriptions(query)
+              end
+
               fin_result = if query.context.errors.empty?
                 result
               else
@@ -184,7 +199,8 @@ module GraphQL
                 res_h
               end
 
-              GraphQL::Query::Result.new(query: query, values: fin_result)
+              query.result_values = fin_result
+              query.result
             end
           end
         ensure
@@ -241,16 +257,17 @@ module GraphQL
           paths_to_check.compact! # root-level auth errors currently come without a path
           # TODO dry with above?
           # This is also where a query-level "Step" would be used?
-          selected_operation = query.document.definitions.first # TODO pick a selected operation
-          root_type = case selected_operation.operation_type
-          when nil, "query"
-            query.schema.query
-          when "mutation"
-            query.schema.mutation
-          when "subscription"
-            raise "Not implemented yet, TODO"
+          if (selected_operation = query.selected_operation)
+            root_type = case selected_operation.operation_type
+            when nil, "query"
+              query.schema.query
+            when "mutation"
+              query.schema.mutation
+            when "subscription"
+              query.schema.subscription
+            end
+            check_object_result(query, data, root_type, selected_operation.selections, [], [], paths_to_check)
           end
-          check_object_result(query, data, root_type, selected_operation.selections, [], [], paths_to_check)
         end
 
         def check_object_result(query, result_h, static_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
@@ -269,22 +286,26 @@ module GraphQL
                   if (result_type_non_null = result_type.non_null?)
                     result_type = result_type.of_type
                   end
+
                   new_result_value = if result_value.is_a?(GraphQL::Error)
                     result_value.path = current_result_path.dup
-                    nil
+                    result_value.assign_graphql_result(query, result_h, key)
+                    result_h.key?(key) ? result_h[key] : :unassigned
                   else
                     if result_type.list?
                       check_list_result(query, result_value, result_type.of_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
-                    elsif result_type.kind.leaf?
-                      result_value
-                    else
+                    elsif !result_type.kind.leaf?
                       check_object_result(query, result_value, result_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
+                    else
+                      result_value
                     end
                   end
 
                   if new_result_value.nil? && result_type_non_null
                     return nil
-                  else
+                  elsif :unassigned.equal?(new_result_value)
+                    # Do nothing
+                  elsif !new_result_value.equal?(result_value)
                     result_h[key] = new_result_value
                   end
                 end
@@ -317,24 +338,25 @@ module GraphQL
           end
 
           new_invalid_null = false
-          result_arr.map!.with_index do |result_item, idx|
+          result_arr.each_with_index do |result_item, idx|
             current_result_path << idx
             new_result = if result_item.is_a?(GraphQL::Error)
               result_item.path = current_result_path.dup
-              nil
+              result_item.assign_graphql_result(query, result_arr, idx)
+              result_arr[idx]
             elsif inner_type.list?
               check_list_result(query, result_item, inner_type.of_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
-            elsif inner_type.kind.leaf?
-              result_item
-            else
+            elsif !inner_type.kind.leaf?
               check_object_result(query, result_item, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+            else
+              result_item
             end
 
             if new_result.nil? && inner_type_non_null
               new_invalid_null = true
-              nil
-            else
-              new_result
+              result_arr[idx] = nil
+            elsif !new_result.equal?(result_item)
+              result_arr[idx] = new_result
             end
           ensure
             current_result_path.pop

data/lib/graphql/execution/next.rb

@@ -52,7 +52,7 @@ module GraphQL
 
       def self.run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
         queries = query_options.map do |opts|
-          case opts
+          query = case opts
           when Hash
             schema.query_class.new(schema, nil, **opts)
           when GraphQL::Query, GraphQL::Query::Partial
@@ -60,6 +60,8 @@ module GraphQL
           else
             raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
           end
+          query.context[:__graphql_execute_next] = true
+          query
         end
         multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
         runner = Runner.new(multiplex, **schema.execution_next_options)

data/lib/graphql/execution.rb

@@ -10,10 +10,13 @@ require "graphql/execution/errors"
 module GraphQL
   module Execution
     # @api private
-    class Skip < GraphQL::Error; end
+    class Skip < GraphQL::RuntimeError
+      attr_accessor :path
+      def ast_nodes=(_ignored); end
 
-    # Just a singleton for implementing {Query::Context#skip}
-    # @api private
-    SKIP = Skip.new
+      def assign_graphql_result(query, result_data, key)
+        result_data.delete(key)
+      end
+    end
   end
 end

data/lib/graphql/execution_error.rb

@@ -6,7 +6,7 @@ module GraphQL
   class ExecutionError < GraphQL::RuntimeError
     # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
     def ast_node
-      ast_nodes.first
+      ast_nodes&.first
     end
 
     def ast_node=(new_node)
@@ -36,6 +36,10 @@ module GraphQL
       super(message)
     end
 
+    def assign_graphql_result(query, result_data, key)
+      result_data[key] = nil
+    end
+
     # @return [Hash] An entry for the response's "errors" key
     def to_h
       hash = {

data/lib/graphql/query/context.rb

@@ -112,7 +112,7 @@ module GraphQL
       # Return this value to tell the runtime
       # to exclude this field from the response altogether
       def skip
-        GraphQL::Execution::SKIP
+        GraphQL::Execution::Skip.new
       end
 
       # Add error at query-level.

data/lib/graphql/schema/field.rb

@@ -665,10 +665,9 @@ module GraphQL
       end
 
       def authorizes?(context)
-        method(:authorized?).owner != GraphQL::Schema::Field || (
-          (args = context.types.arguments(self)) &&
-            (args.any? { |a| a.authorizes?(context) })
-        )
+        method(:authorized?).owner != GraphQL::Schema::Field ||
+          ((args = context.types.arguments(self)) && (args.any? { |a| a.authorizes?(context) })) ||
+          (@resolver_class&.authorizes?(context)) || false
       end
 
       def authorized?(object, args, context)

data/lib/graphql/schema/list.rb

@@ -19,7 +19,7 @@ module GraphQL
       end
 
       def to_type_signature
-        "[#{@of_type.to_type_signature}]"
+        @type_signature ||= -"[#{@of_type.to_type_signature}]"
       end
 
       # This is for introspection, where it's expected the name will be `null`

data/lib/graphql/schema/member/has_fields.rb

@@ -150,10 +150,14 @@ module GraphQL
 
         def global_id_field(field_name, **kwargs)
           type = self
-          field field_name, "ID", **kwargs, null: false
+          field field_name, "ID", **kwargs, null: false, resolve_each: true
           define_method(field_name) do
             context.schema.id_from_object(object, type, context)
           end
+
+          define_singleton_method(field_name) do |object, context|
+            context.schema.id_from_object(object, type, context)
+          end
         end
 
         # @param new_has_no_fields [Boolean] Call with `true` to make this Object type ignore the requirement to have any defined fields.

data/lib/graphql/schema/non_null.rb

@@ -24,7 +24,7 @@ module GraphQL
       end
 
       def to_type_signature
-        "#{@of_type.to_type_signature}!"
+        @type_signature ||= -"#{@of_type.to_type_signature}!"
       end
 
       def inspect