graphql 2.3.12 → 2.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b47194e443275c95a25db554e05a8aa54672503b91e5cce87e422ff04b036502
-  data.tar.gz: b8e052d617025f4b2c20b4db7cdc7f2fc69dc2582518ff768f3ff475d5220f29
+  metadata.gz: c1fd7e53d9729765a9c020960a968e478cf43efca04789f73b64ac226c5bf3c2
+  data.tar.gz: ed151811454729c3ab5fd4c2877bc4cbb19093e0e85faa630b4472b486061d7b
 SHA512:
-  metadata.gz: 65ce3a1c3eed524257063672bc87dc72f98af3ab9c398a1cb06d2388ed7199ec22b85c77ae7db82b854efc0a0f4cd2c2a27062e033725f30dc0082b5bbed71c6
-  data.tar.gz: 04e1f618cf82c8bb08982a2e4ebccba5bfadaff73453e9c09b7c84d22423be2c30a57b9bf61a0ecc15a7f15401e24e72ac4fe33a93be0722f13fcb24f0855891
+  metadata.gz: 564d90c0336b0b7d812843bbd3c7db78855820e6fdeaf8d786149c06dcdf2025aabb11dd31b3621ae0631d8d3fd3c4e222c712fa652e2a24a96af9b2d594d660
+  data.tar.gz: b705e105a0c18dd578bac21978bca5d1229e33cef6d6a627d6a47b2e4fafe711aa9b4a1fc956eece47e8e1c67280af05c74cfa01aa367b3e58d38cd5c7b78cd9

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

@@ -207,22 +207,32 @@ module GraphQL
             finished_jobs = 0
             enqueued_jobs = gathered_selections.size
             gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
-              @dataloader.append_job {
-                evaluate_selection(
-                  result_name, field_ast_nodes_or_ast_node, selections_result
-                )
-                finished_jobs += 1
-                if target_result && finished_jobs == enqueued_jobs
-                  selections_result.merge_into(target_result)
-                end
-              }
+
               # Field resolution may pause the fiber,
               # so it wouldn't get to the `Resolve` call that happens below.
               # So instead trigger a run from this outer context.
               if selections_result.graphql_is_eager
                 @dataloader.clear_cache
-                @dataloader.run
-                @dataloader.clear_cache
+                @dataloader.run_isolated {
+                  evaluate_selection(
+                    result_name, field_ast_nodes_or_ast_node, selections_result
+                  )
+                  finished_jobs += 1
+                  if target_result && finished_jobs == enqueued_jobs
+                    selections_result.merge_into(target_result)
+                  end
+                  @dataloader.clear_cache
+                }
+              else
+                @dataloader.append_job {
+                  evaluate_selection(
+                    result_name, field_ast_nodes_or_ast_node, selections_result
+                  )
+                  finished_jobs += 1
+                  if target_result && finished_jobs == enqueued_jobs
+                    selections_result.merge_into(target_result)
+                  end
+                }
               end
             end
             selections_result

data/lib/graphql/rubocop/graphql/field_type_in_block.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+require_relative "./base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any field whose type configuration isn't given
+      # in the configuration block.
+      #
+      # @example
+      #   # bad, immediately causes Rails to load `app/graphql/types/thing.rb`
+      #   field :thing, Types::Thing
+      #
+      #   # good, defers loading until the file is needed
+      #   field :thing do
+      #     type(Types::Thing)
+      #   end
+      #
+      class FieldTypeInBlock < BaseCop
+        MSG = "type configuration can be moved to a block to defer loading the type's file"
+
+        BUILT_IN_SCALAR_NAMES = ["Float", "Int", "Integer", "String", "ID", "Boolean"]
+        def_node_matcher :field_config_with_inline_type, <<-Pattern
+        (
+          send {nil? _} :field sym ${const array} ...
+        )
+        Pattern
+
+        def_node_matcher :field_config_with_inline_type_and_block, <<-Pattern
+        (
+          block
+            (send {nil? _} :field sym ${const array}) ...
+            (args)
+            _
+
+        )
+        Pattern
+
+        def on_block(node)
+          field_config_with_inline_type_and_block(node) do |type_const|
+            ignore_node(type_const)
+            type_const_str = get_type_argument_str(node, type_const)
+            if ignore_inline_type_str?(type_const_str)
+              # Do nothing ...
+            else
+              add_offense(type_const) do |corrector|
+                cleaned_node_source = delete_type_argument(node, type_const)
+                field_indent = determine_field_indent(node)
+                cleaned_node_source.sub!(/(\{|do)/, "\\1\n#{field_indent}  type #{type_const_str}")
+                corrector.replace(node, cleaned_node_source)
+              end
+            end
+          end
+        end
+
+        def on_send(node)
+          field_config_with_inline_type(node) do |type_const|
+            return if ignored_node?(type_const)
+            type_const_str = get_type_argument_str(node, type_const)
+            if ignore_inline_type_str?(type_const_str)
+              # Do nothing -- not loading from another file
+            else
+              add_offense(type_const) do |corrector|
+                cleaned_node_source = delete_type_argument(node, type_const)
+                field_indent = determine_field_indent(node)
+                cleaned_node_source += " do\n#{field_indent}  type #{type_const_str}\n#{field_indent}end"
+                corrector.replace(node, cleaned_node_source)
+              end
+            end
+          end
+        end
+
+
+        private
+
+        def ignore_inline_type_str?(type_str)
+          BUILT_IN_SCALAR_NAMES.include?(type_str)
+        end
+
+        def get_type_argument_str(send_node, type_const)
+          first_pos = type_const.location.expression.begin_pos
+          end_pos = type_const.location.expression.end_pos
+          node_source = send_node.source_range.source
+          node_first_pos = send_node.location.expression.begin_pos
+
+          relative_first_pos = first_pos - node_first_pos
+          end_removal_pos = end_pos - node_first_pos
+
+          node_source[relative_first_pos...end_removal_pos]
+        end
+
+        def delete_type_argument(send_node, type_const)
+          first_pos = type_const.location.expression.begin_pos
+          end_pos = type_const.location.expression.end_pos
+          node_source = send_node.source_range.source
+          node_first_pos = send_node.location.expression.begin_pos
+
+          relative_first_pos = first_pos - node_first_pos
+          end_removal_pos = end_pos - node_first_pos
+
+          begin_removal_pos = relative_first_pos
+          while node_source[begin_removal_pos] != ","
+            begin_removal_pos -= 1
+            if begin_removal_pos < 1
+              raise "Invariant: somehow backtracked to beginning of node looking for a comma (node source: #{node_source.inspect})"
+            end
+          end
+
+          node_source[0...begin_removal_pos] + node_source[end_removal_pos..-1]
+        end
+
+        def determine_field_indent(send_node)
+          surrounding_node = send_node.parent.parent
+          surrounding_source = surrounding_node.source
+          indent_test_idx = send_node.location.expression.begin_pos - surrounding_node.source_range.begin_pos - 1
+          field_indent = "".dup
+          while surrounding_source[indent_test_idx] == " "
+            field_indent << " "
+            indent_test_idx -= 1
+            if indent_test_idx == 0
+              raise "Invariant: somehow backtracted to beginning of class when looking for field indent (source: #{node_source.inspect})"
+            end
+          end
+          field_indent
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop/graphql/root_types_in_block.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require_relative "./base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any root types in your schema file.
+      #
+      # @example
+      #   # bad, immediately causes Rails to load `app/graphql/types/query.rb`
+      #   query Types::Query
+      #
+      #   # good, defers loading until the file is needed
+      #   query { Types::Query }
+      #
+      class RootTypesInBlock < BaseCop
+        MSG = "type configuration can be moved to a block to defer loading the type's file"
+
+        def_node_matcher :root_type_config_without_block, <<-Pattern
+        (
+          send nil? {:query :mutation :subscription} const
+        )
+        Pattern
+
+        def on_send(node)
+          root_type_config_without_block(node) do
+            add_offense(node) do |corrector|
+              new_node_source = node.source_range.source
+              new_node_source.sub!(/(query|mutation|subscription)/, '\1 {')
+              new_node_source << " }"
+              corrector.replace(node, new_node_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop.rb

@@ -2,3 +2,5 @@
 
 require "graphql/rubocop/graphql/default_null_true"
 require "graphql/rubocop/graphql/default_required_true"
+require "graphql/rubocop/graphql/field_type_in_block"
+require "graphql/rubocop/graphql/root_types_in_block"

data/lib/graphql/schema/addition.rb

@@ -189,6 +189,7 @@ module GraphQL
           add_directives_from(type)
           if type.kind.fields?
             type.all_field_definitions.each do |field|
+              field.ensure_loaded
               name = field.graphql_name
               field_type = field.type.unwrap
               if !field_type.is_a?(GraphQL::Schema::LateBoundType)

data/lib/graphql/schema/enum.rb

@@ -22,9 +22,21 @@ module GraphQL
     class Enum < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::ValidatesInput
 
+      # This is raised when either:
+      #
+      # - A resolver returns a value which doesn't match any of the enum's configured values;
+      # - Or, the resolver returns a value which matches a value, but that value's `authorized?` check returns false.
+      #
+      # In either case, the field should be modified so that the invalid value isn't returned.
+      #
+      # {GraphQL::Schema::Enum} subclasses get their own subclass of this error, so that bug trackers can better show where they came from.
       class UnresolvedValueError < GraphQL::Error
-        def initialize(value:, enum:, context:)
-          fix_message = ", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
+        def initialize(value:, enum:, context:, authorized:)
+          fix_message = if authorized == false
+            ", but this value was unauthorized. Update the field or resolver to return a different value in this case (or return `nil`)."
+          else
+            ", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
+          end
           message = if (cp = context[:current_path]) && (cf = context[:current_field])
             "`#{cf.path}` returned `#{value.inspect}` at `#{cp.join(".")}`#{fix_message}"
           else
@@ -34,6 +46,8 @@ module GraphQL
         end
       end
 
+      # Raised when a {GraphQL::Schema::Enum} is defined to have no values.
+      # This can also happen when all values return false for `.visible?`.
       class MissingValuesError < GraphQL::Error
         def initialize(enum_type)
           @enum_type = enum_type
@@ -43,10 +57,10 @@ module GraphQL
 
       class << self
         # Define a value for this enum
-        # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
-        # @param description [String], the GraphQL description for this value, present in documentation
-        # @param value [Object], the translated Ruby value for this object (defaults to `graphql_name`)
-        # @param deprecation_reason [String] if this object is deprecated, include a message here
+        # @option kwargs [String, Symbol] :graphql_name the GraphQL value for this, usually `SCREAMING_CASE`
+        # @option kwargs [String] :description, the GraphQL description for this value, present in documentation
+        # @option kwargs [::Object] :value the translated Ruby value for this object (defaults to `graphql_name`)
+        # @option kwargs [String] :deprecation_reason if this object is deprecated, include a message here
         # @return [void]
         # @see {Schema::EnumValue} which handles these inputs by default
         def value(*args, **kwargs, &block)
@@ -140,26 +154,39 @@ module GraphQL
           end
         end
 
+        # Called by the runtime when a field returns a value to give back to the client.
+        # This method checks that the incoming {value} matches one of the enum's defined values.
+        # @param value [Object] Any value matching the values for this enum.
+        # @param ctx [GraphQL::Query::Context]
+        # @raise [GraphQL::Schema::Enum::UnresolvedValueError] if {value} doesn't match a configured value or if the matching value isn't authorized.
+        # @return [String] The GraphQL-ready string for {value}
         def coerce_result(value, ctx)
           types = ctx.types
           all_values = types ? types.enum_values(self) : values.each_value
           enum_value = all_values.find { |val| val.value == value }
-          if enum_value
+          if enum_value && (was_authed = enum_value.authorized?(ctx))
             enum_value.graphql_name
           else
-            raise self::UnresolvedValueError.new(enum: self, value: value, context: ctx)
+            raise self::UnresolvedValueError.new(enum: self, value: value, context: ctx, authorized: was_authed)
           end
         end
 
+        # Called by the runtime with incoming string representations from a query.
+        # It will match the string to a configured by name or by Ruby value.
+        # @param value_name [String, Object] A string from a GraphQL query, or a Ruby value matching a `value(..., value: ...)` configuration
+        # @param ctx [GraphQL::Query::Context]
+        # @raise [GraphQL::UnauthorizedEnumValueError] if an {EnumValue} matches but returns false for `.authorized?`. Goes to {Schema.unauthorized_object}.
+        # @return [Object] The Ruby value for the matched {GraphQL::Schema::EnumValue}
         def coerce_input(value_name, ctx)
           all_values = ctx.types ? ctx.types.enum_values(self) : values.each_value
 
-          if v = all_values.find { |val| val.graphql_name == value_name }
-            v.value
-          elsif v = all_values.find { |val| val.value == value_name }
-            # this is for matching default values, which are "inputs", but they're
-            # the Ruby value, not the GraphQL string.
-            v.value
+          # This tries matching by incoming GraphQL string, then checks Ruby-defined values
+          if v = (all_values.find { |val| val.graphql_name == value_name } || all_values.find { |val| val.value == value_name })
+            if v.authorized?(ctx)
+              v.value
+            else
+              raise GraphQL::UnauthorizedEnumValueError.new(type: self, enum_value: v, context: ctx)
+            end
           else
             nil
           end

data/lib/graphql/schema/field.rb

@@ -146,11 +146,16 @@ module GraphQL
             Member::BuildType.to_type_name(@return_type_expr)
           elsif @resolver_class && @resolver_class.type
             Member::BuildType.to_type_name(@resolver_class.type)
-          else
+          elsif type
             # As a last ditch, try to force loading the return type:
             type.unwrap.name
           end
-          @connection = return_type_name.end_with?("Connection") && return_type_name != "Connection"
+          if return_type_name
+            @connection = return_type_name.end_with?("Connection") && return_type_name != "Connection"
+          else
+            # TODO set this when type is set by method
+            false # not loaded yet?
+          end
         else
           @connection
         end
@@ -236,8 +241,8 @@ module GraphQL
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
         if !(resolver_class)
-          if type.nil?
-            raise ArgumentError, "missing second `type` argument or keyword `type:`"
+          if type.nil? && !block_given?
+            raise ArgumentError, "missing second `type` argument, keyword `type:`, or a block containing `type(...)`"
           end
         end
         @original_name = name
@@ -302,6 +307,7 @@ module GraphQL
         @ast_node = ast_node
         @method_conflict_warning = method_conflict_warning
         @fallback_value = fallback_value
+        @definition_block = nil
 
         arguments.each do |name, arg|
           case arg
@@ -320,26 +326,14 @@ module GraphQL
         @subscription_scope = subscription_scope
 
         @extensions = EMPTY_ARRAY
-        @call_after_define = false
-        # This should run before connection extension,
-        # but should it run after the definition block?
-        if scoped?
-          self.extension(ScopeExtension)
-        end
-
-        # The problem with putting this after the definition_block
-        # is that it would override arguments
-        if connection? && connection_extension
-          self.extension(connection_extension)
-        end
-
+        set_pagination_extensions(connection_extension: connection_extension)
         # Do this last so we have as much context as possible when initializing them:
         if extensions.any?
-          self.extensions(extensions)
+          self.extensions(extensions, call_after_define: false)
         end
 
         if resolver_class && resolver_class.extensions.any?
-          self.extensions(resolver_class.extensions)
+          self.extensions(resolver_class.extensions, call_after_define: false)
         end
 
         if directives.any?
@@ -353,15 +347,28 @@ module GraphQL
         end
 
         if block_given?
-          if definition_block.arity == 1
-            yield self
+          @definition_block = definition_block
+        else
+          self.extensions.each(&:after_define_apply)
+        end
+      end
+
+      # Calls the definition block, if one was given.
+      # This is deferred so that references to the return type
+      # can be lazily evaluated, reducing Rails boot time.
+      # @return [self]
+      # @api private
+      def ensure_loaded
+        if @definition_block
+          if @definition_block.arity == 1
+            @definition_block.call(self)
           else
-            instance_eval(&definition_block)
+            instance_eval(&@definition_block)
           end
+          self.extensions.each(&:after_define_apply)
+          @definition_block = nil
         end
-
-        self.extensions.each(&:after_define_apply)
-        @call_after_define = true
+        self
       end
 
       attr_accessor :dynamic_introspection
@@ -408,14 +415,14 @@ module GraphQL
       #
       # @param extensions [Array<Class, Hash<Class => Hash>>] Add extensions to this field. For hash elements, only the first key/value is used.
       # @return [Array<GraphQL::Schema::FieldExtension>] extensions to apply to this field
-      def extensions(new_extensions = nil)
+      def extensions(new_extensions = nil, call_after_define: !@definition_block)
         if new_extensions
           new_extensions.each do |extension_config|
             if extension_config.is_a?(Hash)
               extension_class, options = *extension_config.to_a[0]
-              self.extension(extension_class, options)
+              self.extension(extension_class, call_after_define: call_after_define, **options)
             else
-              self.extension(extension_config)
+              self.extension(extension_config, call_after_define: call_after_define)
             end
           end
         end
@@ -433,12 +440,12 @@ module GraphQL
       # @param extension_class [Class] subclass of {Schema::FieldExtension}
       # @param options [Hash] if provided, given as `options:` when initializing `extension`.
       # @return [void]
-      def extension(extension_class, options = nil)
+      def extension(extension_class, call_after_define: !@definition_block, **options)
         extension_inst = extension_class.new(field: self, options: options)
         if @extensions.frozen?
           @extensions = @extensions.dup
         end
-        if @call_after_define
+        if call_after_define
           extension_inst.after_define_apply
         end
         @extensions << extension_inst
@@ -577,16 +584,29 @@ module GraphQL
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 
-      def type
-        if @resolver_class
-          return_type = @return_type_expr || @resolver_class.type_expr
-          if return_type.nil?
-            raise MissingReturnTypeError, "Can't determine the return type for #{self.path} (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
+      # Get or set the return type of this field.
+      #
+      # It may return nil if no type was configured or if the given definition block wasn't called yet.
+      # @param new_type [Module, GraphQL::Schema::NonNull, GraphQL::Schema::List] A GraphQL return type
+      # @return [Module, GraphQL::Schema::NonNull, GraphQL::Schema::List, nil] the configured type for this field
+      def type(new_type = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_type)
+          if @resolver_class
+            return_type = @return_type_expr || @resolver_class.type_expr
+            if return_type.nil?
+              raise MissingReturnTypeError, "Can't determine the return type for #{self.path} (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
+            end
+            nullable = @return_type_null.nil? ? @resolver_class.null : @return_type_null
+            Member::BuildType.parse_type(return_type, null: nullable)
+          elsif !@return_type_expr.nil?
+            @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
           end
-          nullable = @return_type_null.nil? ? @resolver_class.null : @return_type_null
-          Member::BuildType.parse_type(return_type, null: nullable)
         else
-          @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          @return_type_expr = new_type
+          # If `type` is set in the definition block, then the `connection_extension: ...` given as a keyword won't be used, hmm...
+          # Also, arguments added by `connection_extension` will clobber anything previously defined,
+          # so `type(...)` should go first.
+          set_pagination_extensions(connection_extension: self.class.connection_extension)
         end
       rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err
         # Let this propagate up
@@ -897,6 +917,20 @@ ERR
           raise ArgumentError, "Invalid complexity for #{self.path}: #{own_complexity.inspect}"
         end
       end
+
+      def set_pagination_extensions(connection_extension:)
+        # This should run before connection extension,
+        # but should it run after the definition block?
+        if scoped?
+          self.extension(ScopeExtension, call_after_define: false)
+        end
+
+        # The problem with putting this after the definition_block
+        # is that it would override arguments
+        if connection? && connection_extension
+          self.extension(connection_extension, call_after_define: false)
+        end
+      end
     end
   end
 end

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

@@ -121,7 +121,7 @@ module GraphQL
                   # Choose the most local definition that passes `.visible?` --
                   # stop checking for fields by name once one has been found.
                   if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
-                    visible_fields[field_name] = f
+                    visible_fields[field_name] = f.ensure_loaded
                   end
                 end
               end
@@ -142,7 +142,7 @@ module GraphQL
                   visible_interface_implementation?(ancestor, context, warden) &&
                   (f_entry = ancestor.own_fields[field_name]) &&
                   (skip_visible || (f_entry = Warden.visible_entry?(:visible_field?, f_entry, context, warden)))
-                return f_entry
+                return (skip_visible ? f_entry : f_entry.ensure_loaded)
               end
               i += 1
             end
@@ -161,7 +161,7 @@ module GraphQL
                   # Choose the most local definition that passes `.visible?` --
                   # stop checking for fields by name once one has been found.
                   if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
-                    visible_fields[field_name] = f
+                    visible_fields[field_name] = f.ensure_loaded
                   end
                 end
               end

data/lib/graphql/schema/subset.rb

@@ -129,7 +129,7 @@ module GraphQL
         end.compare_by_identity
 
         @cached_fields = Hash.new do |h, owner|
-          h[owner] = non_duplicate_items(owner.all_field_definitions, @cached_visible_fields[owner])
+          h[owner] = non_duplicate_items(owner.all_field_definitions.each(&:ensure_loaded), @cached_visible_fields[owner])
         end.compare_by_identity
 
         @cached_arguments = Hash.new do |h, owner|
@@ -213,13 +213,11 @@ module GraphQL
               end
             end
           end
-          visible_f
+          visible_f.ensure_loaded
+        elsif f && @cached_visible_fields[owner][f.ensure_loaded]
+          f
         else
-          if f && @cached_visible_fields[owner][f]
-            f
-          else
-            nil
-          end
+          nil
         end
       end
 
@@ -446,6 +444,7 @@ module GraphQL
           # recurse into visible fields
           t_f = type.all_field_definitions
           t_f.each do |field|
+            field.ensure_loaded
             if @cached_visible[field]
               visit_directives(field)
               field_type = field.type.unwrap

data/lib/graphql/schema/types_migration.rb

@@ -165,6 +165,8 @@ module GraphQL
             equivalent_schema_members?(inner_member1, inner_member2)
           end
         when GraphQL::Schema::Field
+          member1.ensure_loaded
+          member2.ensure_loaded
           if member1.introspection? && member2.introspection?
             member1.inspect == member2.inspect
           else

data/lib/graphql/schema/validator/all_validator.rb

@@ -28,6 +28,8 @@ module GraphQL
         end
 
         def validate(object, context, value)
+          return EMPTY_ARRAY if permitted_empty_value?(value)
+
           all_errors = EMPTY_ARRAY
 
           value.each do |subvalue|

data/lib/graphql/schema.rb

@@ -430,44 +430,60 @@ module GraphQL
         end
       end
 
-      def query(new_query_object = nil)
-        if new_query_object
+      def query(new_query_object = nil, &lazy_load_block)
+        if new_query_object || block_given?
           if @query_object
-            raise GraphQL::Error, "Second definition of `query(...)` (#{new_query_object.inspect}) is invalid, already configured with #{@query_object.inspect}"
+            dup_defn = new_query_object || yield
+            raise GraphQL::Error, "Second definition of `query(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@query_object.inspect}"
+          elsif use_schema_subset?
+            @query_object = block_given? ? lazy_load_block : new_query_object
           else
-            @query_object = new_query_object
-            add_type_and_traverse(new_query_object, root: true) unless use_schema_subset?
-            nil
+            @query_object = new_query_object || lazy_load_block.call
+            add_type_and_traverse(@query_object, root: true)
           end
+          nil
+        elsif @query_object.is_a?(Proc)
+          @query_object = @query_object.call
         else
           @query_object || find_inherited_value(:query)
         end
       end
 
-      def mutation(new_mutation_object = nil)
-        if new_mutation_object
+      def mutation(new_mutation_object = nil, &lazy_load_block)
+        if new_mutation_object || block_given?
           if @mutation_object
-            raise GraphQL::Error, "Second definition of `mutation(...)` (#{new_mutation_object.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
+            dup_defn = new_mutation_object || yield
+            raise GraphQL::Error, "Second definition of `mutation(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
+          elsif use_schema_subset?
+            @mutation_object = block_given? ? lazy_load_block : new_mutation_object
           else
-            @mutation_object = new_mutation_object
-            add_type_and_traverse(new_mutation_object, root: true) unless use_schema_subset?
-            nil
+            @mutation_object = new_mutation_object || lazy_load_block.call
+            add_type_and_traverse(@mutation_object, root: true)
           end
+          nil
+        elsif @mutation_object.is_a?(Proc)
+          @mutation_object = @mutation_object.call
         else
           @mutation_object || find_inherited_value(:mutation)
         end
       end
 
-      def subscription(new_subscription_object = nil)
-        if new_subscription_object
+      def subscription(new_subscription_object = nil, &lazy_load_block)
+        if new_subscription_object || block_given?
           if @subscription_object
-            raise GraphQL::Error, "Second definition of `subscription(...)` (#{new_subscription_object.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
+            dup_defn = new_subscription_object || yield
+            raise GraphQL::Error, "Second definition of `subscription(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
+          elsif use_schema_subset?
+            @subscription_object = block_given? ? lazy_load_block : new_subscription_object
           else
-            @subscription_object = new_subscription_object
-            add_subscription_extension_if_necessary
-            add_type_and_traverse(new_subscription_object, root: true) unless use_schema_subset?
-            nil
+            @subscription_object = new_subscription_object || lazy_load_block.call
+            add_type_and_traverse(@subscription_object, root: true)
           end
+          nil
+        elsif @subscription_object.is_a?(Proc)
+          @subscription_object = @subscription_object.call
+          add_subscription_extension_if_necessary
+          @subscription_object
         else
           @subscription_object || find_inherited_value(:subscription)
         end
@@ -1373,7 +1389,8 @@ module GraphQL
 
       # @api private
       def add_subscription_extension_if_necessary
-        if !defined?(@subscription_extension_added) && subscription && self.subscriptions
+        # TODO: when there's a proper API for extending root types, migrat this to use it.
+        if !defined?(@subscription_extension_added) && @subscription_object.is_a?(Class) && self.subscriptions
           @subscription_extension_added = true
           subscription.all_field_definitions.each do |field|
             if !field.extensions.any? { |ext| ext.is_a?(Subscriptions::DefaultSubscriptionResolveExtension) }

data/lib/graphql/unauthorized_enum_value_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module GraphQL
+  class UnauthorizedEnumValueError < GraphQL::UnauthorizedError
+    # @return [GraphQL::Schema::EnumValue] The value whose `#authorized?` check returned false
+    attr_accessor :enum_value
+
+    def initialize(type:, context:, enum_value:)
+      @enum_value = enum_value
+      message ||= "#{enum_value.path} failed authorization"
+      super(message, object: enum_value.value, type: type, context: context)
+    end
+  end
+end

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -119,6 +119,7 @@ require "graphql/parse_error"
 require "graphql/backtrace"
 
 require "graphql/unauthorized_error"
+require "graphql/unauthorized_enum_value_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
 require "graphql/testing"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.3.12
+  version: 2.3.13
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-05 00:00:00.000000000 Z
+date: 2024-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -422,6 +422,8 @@ files:
 - lib/graphql/rubocop/graphql/base_cop.rb
 - lib/graphql/rubocop/graphql/default_null_true.rb
 - lib/graphql/rubocop/graphql/default_required_true.rb
+- lib/graphql/rubocop/graphql/field_type_in_block.rb
+- lib/graphql/rubocop/graphql/root_types_in_block.rb
 - lib/graphql/runtime_type_error.rb
 - lib/graphql/schema.rb
 - lib/graphql/schema/addition.rb
@@ -630,6 +632,7 @@ files:
 - lib/graphql/types/relay/page_info.rb
 - lib/graphql/types/relay/page_info_behaviors.rb
 - lib/graphql/types/string.rb
+- lib/graphql/unauthorized_enum_value_error.rb
 - lib/graphql/unauthorized_error.rb
 - lib/graphql/unauthorized_field_error.rb
 - lib/graphql/unresolved_type_error.rb