graphql 1.11.3 → 1.11.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f64724e3b46476cf0a622ef5d5d1beb4360c7d5de031907d5173cb462928ee4
-  data.tar.gz: 9b8098bab2bfdc704bf98dc011a452f1bce8c480c9435f1b37a79430ee81bc06
+  metadata.gz: c5bf42de25927dab863bd600879d33d204c54bdf124b2b4cc5b27c4c16d4f28b
+  data.tar.gz: 58b21a4dd5ba80ec0f6c3362013a6adb07c2f1af243e5a851d4c3f08554fe09d
 SHA512:
-  metadata.gz: 6dabc15fe0688fc37233e23f5bc5647bf55ad176456257c088e15a87f7fabc07b6da43e86efcd9e982ecfc8b47c6eca331a0ced9a82f20076c21aa4ccf20f223
-  data.tar.gz: d98a3193ab5759d206aabf9db378c38c669cbc2752f4b8908484fcf2cbee9012f00721403ffe999cd19e43016a6b27bd2c0f5f1dc602b93543772f1e7a4791b5
+  metadata.gz: f199d24a190910e44b189340b6a3d2a3c121ab56ba10ec6cf44d8801107db8d73541f24788b00b13ee7dd357f7bfe6ecff7001f053fe417c777bca59db5851db
+  data.tar.gz: fd0955c7f67b20370ea376d6a286fdf0ac7272ac5b243d6c309d2159a780cd0b8f92fd0e06ca312a69a16b7c8ad0ebd7bb4587feac9dc77b27da507c9a44cd8f

data/lib/generators/graphql/core.rb

@@ -41,6 +41,14 @@ module Graphql
         end
       end
 
+      def module_namespacing_when_supported
+        if defined?(module_namespacing)
+          module_namespacing { yield }
+        else
+          yield
+        end
+      end
+
       private
 
       def schema_name

data/lib/generators/graphql/templates/base_argument.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseArgument < GraphQL::Schema::Argument
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_enum.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseEnum < GraphQL::Schema::Enum
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_field.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseField < GraphQL::Schema::Field
     argument_class Types::BaseArgument
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_input_object.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject
     argument_class Types::BaseArgument
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_interface.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   module BaseInterface
     include GraphQL::Schema::Interface
@@ -5,3 +6,4 @@ module Types
     field_class Types::BaseField
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_mutation.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Mutations
   class BaseMutation < GraphQL::Schema::RelayClassicMutation
     argument_class Types::BaseArgument
@@ -6,3 +7,4 @@ module Mutations
     object_class Types::BaseObject
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_object.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseObject < GraphQL::Schema::Object
     field_class Types::BaseField
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_scalar.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseScalar < GraphQL::Schema::Scalar
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_union.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseUnion < GraphQL::Schema::Union
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/enum.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseEnum
 <% prepared_values.each do |v| %>    value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 class GraphqlController < ApplicationController
   # If accessing from outside this domain, nullify the session
   # This allows for outside API access while preventing CSRF attacks,
@@ -48,3 +49,4 @@ class GraphqlController < ApplicationController
     render json: { errors: [{ message: e.message, backtrace: e.backtrace }], data: {} }, status: 500
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/interface.erb

@@ -1,6 +1,8 @@
+<% module_namespacing_when_supported do -%>
 module Types
   module <%= type_ruby_name.split('::')[-1] %>
     include Types::BaseInterface
 <% normalized_fields.each do |f| %>    <%= f.to_ruby %>
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/loader.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Loaders
   class <%= class_name %> < GraphQL::Batch::Loader
     # Define `initialize` to store grouping arguments, eg
@@ -15,3 +16,4 @@ module Loaders
     end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/mutation.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Mutations
   class <%= mutation_name %> < BaseMutation
     # TODO: define return fields
@@ -12,3 +13,4 @@ module Mutations
     # end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/mutation_type.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class MutationType < Types::BaseObject
     # TODO: remove me
@@ -8,3 +9,4 @@ module Types
     end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/object.erb

@@ -1,6 +1,8 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
 <% if options.node %>    implements GraphQL::Relay::Node.interface
 <% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/query_type.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class QueryType < Types::BaseObject
     # Add root-level fields here.
@@ -13,3 +14,4 @@ module Types
     field :node, field: GraphQL::Relay::Node.field
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/scalar.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseScalar
     def self.coerce_input(input_value, context)
@@ -11,3 +12,4 @@ module Types
     end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/schema.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)
 
@@ -38,3 +39,4 @@ class <%= schema_name %> < GraphQL::Schema
   # GraphQL::Batch setup:
   use GraphQL::Batch
 <% end %>end
+<% end -%>

data/lib/generators/graphql/templates/union.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseUnion
 <% if possible_types.any? %>    possible_types [<%= normalized_possible_types.join(", ") %>]
 <% end %>  end
 end
+<% end -%>

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

@@ -170,13 +170,13 @@ module GraphQL
             begin
               kwarg_arguments = arguments(object, field_defn, ast_node)
             rescue GraphQL::ExecutionError => e
-              continue_value(next_path, e, field_defn, return_type.non_null?, ast_node)
+              continue_value(next_path, e, owner_type, field_defn, return_type.non_null?, ast_node)
               next
             end
 
             after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
               if resolved_arguments.is_a? GraphQL::ExecutionError
-                continue_value(next_path, resolved_arguments, field_defn, return_type.non_null?, ast_node)
+                continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node)
                 next
               end
 
@@ -228,12 +228,12 @@ module GraphQL
                   err
                 end
                 after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
-                  continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
+                  continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node)
                   if RawValue === continue_value
                     # Write raw value directly to the response without resolving nested objects
                     write_in_response(next_path, continue_value.resolve)
                   elsif HALT != continue_value
-                    continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
+                    continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
                   end
                 end
               end
@@ -251,10 +251,9 @@ module GraphQL
         end
 
         HALT = Object.new
-        def continue_value(path, value, field, is_non_null, ast_node)
+        def continue_value(path, value, parent_type, field, is_non_null, ast_node)
           if value.nil?
             if is_non_null
-              parent_type = field.owner_type
               err = parent_type::InvalidNullError.new(parent_type, field, value)
               write_invalid_null_in_response(path, err)
             else
@@ -282,7 +281,7 @@ module GraphQL
               err
             end
 
-            continue_value(path, next_value, field, is_non_null, ast_node)
+            continue_value(path, next_value, parent_type, field, is_non_null, ast_node)
           elsif GraphQL::Execution::Execute::SKIP == value
             HALT
           else
@@ -298,49 +297,49 @@ module GraphQL
         # Location information from `path` and `ast_node`.
         #
         # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
-        def continue_field(path, value, field, type, ast_node, next_selections, is_non_null, owner_object, arguments) # rubocop:disable Metrics/ParameterLists
-          case type.kind.name
+        def continue_field(path, value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments) # rubocop:disable Metrics/ParameterLists
+          case current_type.kind.name
           when "SCALAR", "ENUM"
-            r = type.coerce_result(value, context)
+            r = current_type.coerce_result(value, context)
             write_in_response(path, r)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy, resolved_value = resolve_type(type, value, path)
+            resolved_type_or_lazy, resolved_value = resolve_type(current_type, value, path)
             resolved_value ||= value
 
-            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
-              possible_types = query.possible_types(type)
+            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
+              possible_types = query.possible_types(current_type)
 
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
-                err_class = type::UnresolvedTypeError
+                err_class = current_type::UnresolvedTypeError
                 type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
                 write_in_response(path, nil)
                 nil
               else
-                continue_field(path, resolved_value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
+                continue_field(path, resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
               end
             end
           when "OBJECT"
             object_proxy = begin
-              authorized_new(type, value, context, path)
+              authorized_new(current_type, value, context, path)
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |inner_object|
-              continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
+            after_lazy(object_proxy, owner: current_type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |inner_object|
+              continue_value = continue_value(path, inner_object, owner_type, field, is_non_null, ast_node)
               if HALT != continue_value
                 response_hash = {}
                 write_in_response(path, response_hash)
-                evaluate_selections(path, context.scoped_context, continue_value, type, next_selections)
+                evaluate_selections(path, context.scoped_context, continue_value, current_type, next_selections)
                 response_hash
               end
             end
           when "LIST"
             response_list = []
             write_in_response(path, response_list)
-            inner_type = type.of_type
+            inner_type = current_type.of_type
             idx = 0
             scoped_context = context.scoped_context
             begin
@@ -352,9 +351,9 @@ module GraphQL
                 set_type_at_path(next_path, inner_type)
                 # This will update `response_list` with the lazy
                 after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
-                  continue_value = continue_value(next_path, inner_inner_value, field, inner_type.non_null?, ast_node)
+                  continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node)
                   if HALT != continue_value
-                    continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
+                    continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
                   end
                 end
               end
@@ -371,12 +370,12 @@ module GraphQL
 
             response_list
           when "NON_NULL"
-            inner_type = type.of_type
+            inner_type = current_type.of_type
             # Don't `set_type_at_path` because we want the static type,
             # we're going to use that to determine whether a `nil` should be propagated or not.
-            continue_field(path, value, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
+            continue_field(path, value, owner_type, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
           else
-            raise "Invariant: Unhandled type kind #{type.kind} (#{type})"
+            raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
           end
         end
 

data/lib/graphql/query/context.rb

@@ -168,7 +168,6 @@ module GraphQL
       attr_accessor :scoped_context
 
       def_delegators :@provided_values, :[]=
-      def_delegators :to_h, :fetch, :dig
       def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
@@ -180,6 +179,26 @@ module GraphQL
         @provided_values[key]
       end
 
+      UNSPECIFIED_FETCH_DEFAULT = Object.new
+
+      def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif default != UNSPECIFIED_FETCH_DEFAULT
+          default
+        elsif block_given?
+          yield(self, key)
+        else
+          raise KeyError.new(key: key)
+        end
+      end
+
+      def dig(key, *other_keys)
+        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+      end
+
       def to_h
         @provided_values.merge(@scoped_context)
       end

data/lib/graphql/query/fingerprint.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest/sha2'
+
 module GraphQL
   class Query
     # @api private

data/lib/graphql/query/validation_pipeline.rb

@@ -90,6 +90,9 @@ module GraphQL
         end
 
         @valid = @validation_errors.empty?
+      rescue SystemStackError => err
+        @valid = false
+        @schema.query_stack_error(@query, err)
       end
 
       # If there are max_* values, add them,

data/lib/graphql/schema.rb

@@ -1663,6 +1663,10 @@ module GraphQL
         end
       end
 
+      def query_stack_error(query, err)
+        query.analysis_errors.push(GraphQL::AnalysisError.new("This query is too large to execute."))
+      end
+
       private
 
       def lazy_methods

data/lib/graphql/schema/field/connection_extension.rb

@@ -44,7 +44,7 @@ module GraphQL
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size
               end
-              if (custom_t = context.schema.connections.edge_class_for_field(@field))
+              if context.schema.new_connections? && (custom_t = context.schema.connections.edge_class_for_field(@field))
                 value.edge_class = custom_t
               end
               value

data/lib/graphql/schema/subscription.rb

@@ -12,16 +12,6 @@ module GraphQL
     #
     # Also, `#unsubscribe` terminates the subscription.
     class Subscription < GraphQL::Schema::Resolver
-      class EarlyTerminationError < StandardError
-      end
-
-      # Raised when `unsubscribe` is called; caught by `subscriptions.rb`
-      class UnsubscribedError < EarlyTerminationError
-      end
-
-      # Raised when `no_update` is returned; caught by `subscriptions.rb`
-      class NoUpdateError < EarlyTerminationError
-      end
       extend GraphQL::Schema::Resolver::HasPayloadType
       extend GraphQL::Schema::Member::HasFields
 
@@ -65,7 +55,7 @@ module GraphQL
       def resolve_update(**args)
         ret_val = args.any? ? update(**args) : update
         if ret_val == :no_update
-          raise NoUpdateError
+          throw :graphql_no_subscription_update
         else
           ret_val
         end
@@ -90,7 +80,7 @@ module GraphQL
 
       # Call this to halt execution and remove this subscription from the system
       def unsubscribe
-        raise UnsubscribedError
+        throw :graphql_subscription_unsubscribed
       end
 
       READING_SCOPE = ::Object.new

data/lib/graphql/schema/warden.rb

@@ -40,7 +40,6 @@ module GraphQL
       # @param filter [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
-      # @param deep_check [Boolean]
       def initialize(filter, context:, schema:)
         @schema = schema.interpreter? ? schema : schema.graphql_definition
         # Cache these to avoid repeated hits to the inheritance chain when one isn't present
@@ -51,7 +50,7 @@ module GraphQL
         @visibility_cache = read_through { |m| filter.call(m, context) }
       end
 
-      # @return [Array<GraphQL::BaseType>] Visible types in the schema
+      # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
       def types
         @types ||= begin
           vis_types = {}
@@ -199,7 +198,7 @@ module GraphQL
             if (iface_field_defn = interface_type.get_field(field_defn.graphql_name))
               any_interface_has_field = true
 
-              if visible?(interface_type) && visible_field?(interface_type, iface_field_defn)
+              if interfaces(type_defn).include?(interface_type) && visible_field?(interface_type, iface_field_defn)
                 any_interface_has_visible_field = true
               end
             end

data/lib/graphql/subscriptions.rb

@@ -100,31 +100,43 @@ module GraphQL
       # Lookup the saved data for this subscription
       query_data = read_subscription(subscription_id)
       if query_data.nil?
-        # Jump down to the `delete_subscription` call
-        raise GraphQL::Schema::Subscription::UnsubscribedError
+        delete_subscription(subscription_id)
+        return nil
       end
+
       # Fetch the required keys from the saved data
       query_string = query_data.fetch(:query_string)
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      # Re-evaluate the saved query
-      @schema.execute(
-        query: query_string,
-        context: context,
-        subscription_topic: event.topic,
-        operation_name: operation_name,
-        variables: variables,
-        root_value: object,
-      )
-    rescue GraphQL::Schema::Subscription::NoUpdateError
-      # This update was skipped in user code; do nothing.
-      nil
-    rescue GraphQL::Schema::Subscription::UnsubscribedError
-      # `unsubscribe` was called, clean up on our side
-      # TODO also send `{more: false}` to client?
-      delete_subscription(subscription_id)
-      nil
+      result = nil
+      # this will be set to `false` unless `.execute` is terminated
+      # with a `throw :graphql_subscription_unsubscribed`
+      unsubscribed = true
+      catch(:graphql_subscription_unsubscribed) do
+        catch(:graphql_no_subscription_update) do
+          # Re-evaluate the saved query,
+          # but if it terminates early with a `throw`,
+          # it will stay `nil`
+          result = @schema.execute(
+            query: query_string,
+            context: context,
+            subscription_topic: event.topic,
+            operation_name: operation_name,
+            variables: variables,
+            root_value: object,
+          )
+        end
+        unsubscribed = false
+      end
+
+      if unsubscribed
+        # `unsubscribe` was called, clean up on our side
+        # TODO also send `{more: false}` to client?
+        delete_subscription(subscription_id)
+      end
+
+      result
     end
 
     # Run the update query for this subscription and deliver it

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -55,7 +55,15 @@ module GraphQL
       end
 
       def platform_field_key(type, field)
-        "graphql.#{type.name}.#{field.name}"
+        "graphql.#{type.graphql_name}.#{field.graphql_name}"
+      end
+      
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
       end
 
       private
@@ -107,7 +115,7 @@ module GraphQL
           else
             [key, data[key]]
           end
-        end.flatten.each_slice(2).to_h.merge(Spec: 'graphql')
+        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 

data/lib/graphql/types/iso_8601_date_time.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 require 'time'
 
-# frozen_string_literal: true
 module GraphQL
   module Types
     # This scalar takes `Time`s and transmits them as strings,

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

@@ -48,7 +48,7 @@ module GraphQL
           # It's called when you subclass this base connection, trying to use the
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true)
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true, node_nullable: true)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -61,7 +61,7 @@ module GraphQL
               description: "A list of edges.",
               edge_class: edge_class
 
-            define_nodes_field if nodes_field
+            define_nodes_field(node_nullable) if nodes_field
 
             description("The connection type for #{node_type_name}.")
           end
@@ -90,9 +90,10 @@ module GraphQL
 
           private
 
-          def define_nodes_field
-            field :nodes, [@node_type, null: true],
-              null: true,
+          def define_nodes_field(nullable = true)
+            type = nullable ? [@node_type, null: true] : [@node_type]
+            field :nodes, type,
+              null: nullable,
               description: "A list of nodes."
           end
         end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.11.3"
+  VERSION = "1.11.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.11.3
+  version: 1.11.4
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-13 00:00:00.000000000 Z
+date: 2020-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips