graphql 1.12.0 → 1.12.5

data/lib/graphql/schema/argument.rb

@@ -236,6 +236,67 @@ module GraphQL
         end
       end
 
+      # @api private
+      def coerce_into_values(parent_object, values, context, argument_values)
+        arg_name = graphql_name
+        arg_key = keyword
+        has_value = false
+        default_used = false
+        if values.key?(arg_name)
+          has_value = true
+          value = values[arg_name]
+        elsif values.key?(arg_key)
+          has_value = true
+          value = values[arg_key]
+        elsif default_value?
+          has_value = true
+          value = default_value
+          default_used = true
+        end
+
+        if has_value
+          loaded_value = nil
+          coerced_value = context.schema.error_handler.with_error_handling(context) do
+            type.coerce_input(value, context)
+          end
+
+          # TODO this should probably be inside after_lazy
+          if loads && !from_resolver?
+            loaded_value = if type.list?
+              loaded_values = coerced_value.map { |val| owner.load_application_object(self, loads, val, context) }
+              context.schema.after_any_lazies(loaded_values) { |result| result }
+            else
+              owner.load_application_object(self, loads, coerced_value, context)
+            end
+          end
+
+          coerced_value = if loaded_value
+            loaded_value
+          else
+            coerced_value
+          end
+
+          # If this isn't lazy, then the block returns eagerly and assigns the result here
+          # If it _is_ lazy, then we write the lazy to the hash, then update it later
+          argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |coerced_value|
+            owner.validate_directive_argument(self, coerced_value)
+            prepared_value = context.schema.error_handler.with_error_handling(context) do
+              prepare_value(parent_object, coerced_value, context: context)
+            end
+
+            # TODO code smell to access such a deeply-nested constant in a distant module
+            argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+              value: prepared_value,
+              definition: self,
+              default_used: default_used,
+            )
+          end
+        else
+          # has_value is false
+          owner.validate_directive_argument(self, nil)
+        end
+      end
+
       private
 
       def validate_input_type(input_type)

data/lib/graphql/schema/field.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../object.rb
 require "graphql/schema/field/connection_extension"
 require "graphql/schema/field/scope_extension"
 
@@ -61,6 +60,10 @@ module GraphQL
         @introspection
       end
 
+      def inspect
+        "#<#{self.class} #{path}#{arguments.any? ? "(...)" : ""}: #{type.to_type_signature}>"
+      end
+
       alias :mutation :resolver
 
       # @return [Boolean] Apply tracing to this field? (Default: skip scalars, this is the override value)
@@ -83,10 +86,10 @@ module GraphQL
       def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
         if kwargs[:field]
           if kwargs[:field].is_a?(GraphQL::Field) && kwargs[:field] == GraphQL::Types::Relay::NodeField.graphql_definition
-            warn("Legacy-style `GraphQL::Relay::Node.field` is being added to a class-based type. See `GraphQL::Types::Relay::NodeField` for a replacement.")
+            GraphQL::Deprecation.warn("Legacy-style `GraphQL::Relay::Node.field` is being added to a class-based type. See `GraphQL::Types::Relay::NodeField` for a replacement.")
             return GraphQL::Types::Relay::NodeField
           elsif kwargs[:field].is_a?(GraphQL::Field) && kwargs[:field] == GraphQL::Types::Relay::NodesField.graphql_definition
-            warn("Legacy-style `GraphQL::Relay::Node.plural_field` is being added to a class-based type. See `GraphQL::Types::Relay::NodesField` for a replacement.")
+            GraphQL::Deprecation.warn("Legacy-style `GraphQL::Relay::Node.plural_field` is being added to a class-based type. See `GraphQL::Types::Relay::NodesField` for a replacement.")
             return GraphQL::Types::Relay::NodesField
           end
         end
@@ -285,22 +288,24 @@ module GraphQL
         @owner = owner
         @subscription_scope = subscription_scope
 
-        # Do this last so we have as much context as possible when initializing them:
         @extensions = EMPTY_ARRAY
-        if extensions.any?
-          self.extensions(extensions)
-        end
         # 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
 
+        # Do this last so we have as much context as possible when initializing them:
+        if extensions.any?
+          self.extensions(extensions)
+        end
+
         if directives.any?
           directives.each do |(dir_class, options)|
             self.directive(dir_class, **options)

data/lib/graphql/schema/find_inherited_value.rb

@@ -20,7 +20,9 @@ module GraphQL
         if self.is_a?(Class)
           superclass.respond_to?(method_name, true) ? superclass.send(method_name) : default_value
         else
-          ancestors[1..-1].each do |ancestor|
+          ancestors_except_self = ancestors
+          ancestors_except_self.delete(self)
+          ancestors_except_self.each do |ancestor|
             if ancestor.respond_to?(method_name, true)
               return ancestor.send(method_name)
             end

data/lib/graphql/schema/input_object.rb

@@ -214,8 +214,12 @@ module GraphQL
           arguments = coerce_arguments(nil, value, ctx)
 
           ctx.schema.after_lazy(arguments) do |resolved_arguments|
-            input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
-            input_obj_instance.prepare
+            if resolved_arguments.is_a?(GraphQL::Error)
+              raise resolved_arguments
+            else
+              input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
+              input_obj_instance.prepare
+            end
           end
         end
 

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

@@ -81,79 +81,66 @@ module GraphQL
         end
 
         # @api private
+        # If given a block, it will eventually yield the loaded args to the block.
+        #
+        # If no block is given, it will immediately dataload (but might return a Lazy).
+        #
         # @param values [Hash<String, Object>]
         # @param context [GraphQL::Query::Context]
-        # @return [Hash<Symbol, Object>, Execution::Lazy<Hash>]
-        def coerce_arguments(parent_object, values, context)
+        # @yield [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
+          total_args_count = arg_defns.size
 
-          if arg_defns.empty?
-            GraphQL::Execution::Interpreter::Arguments::EMPTY
+          if total_args_count == 0
+            final_args = GraphQL::Execution::Interpreter::Arguments::EMPTY
+            if block_given?
+              block.call(final_args)
+              nil
+            else
+              final_args
+            end
           else
+            finished_args = nil
             argument_values = {}
-            arg_lazies = arg_defns.map do |arg_name, arg_defn|
-              arg_key = arg_defn.keyword
-              has_value = false
-              default_used = false
-              if values.key?(arg_name)
-                has_value = true
-                value = values[arg_name]
-              elsif values.key?(arg_key)
-                has_value = true
-                value = values[arg_key]
-              elsif arg_defn.default_value?
-                has_value = true
-                value = arg_defn.default_value
-                default_used = true
-              end
-
-              if has_value
-                loads = arg_defn.loads
-                loaded_value = nil
-                coerced_value = context.schema.error_handler.with_error_handling(context) do
-                  arg_defn.type.coerce_input(value, context)
-                end
-
-                # TODO this should probably be inside after_lazy
-                if loads && !arg_defn.from_resolver?
-                  loaded_value = if arg_defn.type.list?
-                    loaded_values = coerced_value.map { |val| load_application_object(arg_defn, loads, val, context) }
-                    context.schema.after_any_lazies(loaded_values) { |result| result }
+            resolved_args_count = 0
+            raised_error = false
+            arg_defns.each do |arg_name, arg_defn|
+              context.dataloader.append_job do
+                begin
+                  arg_defn.coerce_into_values(parent_object, values, context, argument_values)
+                rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
+                  raised_error = true
+                  if block_given?
+                    block.call(err)
                   else
-                    load_application_object(arg_defn, loads, coerced_value, context)
+                    finished_args = err
                   end
                 end
 
-                coerced_value = if loaded_value
-                  loaded_value
-                else
-                  coerced_value
-                end
+                resolved_args_count += 1
+                if resolved_args_count == total_args_count && !raised_error
+                  finished_args = context.schema.after_any_lazies(argument_values.values) {
+                    GraphQL::Execution::Interpreter::Arguments.new(
+                      argument_values: argument_values,
+                    )
+                  }
 
-                context.schema.after_lazy(coerced_value) do |coerced_value|
-                  validate_directive_argument(arg_defn, coerced_value)
-                  prepared_value = context.schema.error_handler.with_error_handling(context) do
-                    arg_defn.prepare_value(parent_object, coerced_value, context: context)
+                  if block_given?
+                    block.call(finished_args)
                   end
-
-                  # TODO code smell to access such a deeply-nested constant in a distant module
-                  argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
-                    value: prepared_value,
-                    definition: arg_defn,
-                    default_used: default_used,
-                  )
                 end
-              else
-                # has_value is false
-                validate_directive_argument(arg_defn, nil)
               end
             end
 
-            context.schema.after_any_lazies(arg_lazies) do
-              GraphQL::Execution::Interpreter::Arguments.new(
-                argument_values: argument_values,
-              )
+            if block_given?
+              nil
+            else
+              # This API returns eagerly, gotta run it now
+              context.dataloader.run
+              finished_args
             end
           end
         end

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

@@ -74,11 +74,8 @@ module GraphQL
             @field_class = new_field_class
           elsif defined?(@field_class) && @field_class
             @field_class
-          elsif self.is_a?(Class)
-            superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field
           else
-            ancestor = ancestors[1..-1].find { |a| a.respond_to?(:field_class) && a.field_class }
-            ancestor ? ancestor.field_class : GraphQL::Schema::Field
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../object.rb
 
 module GraphQL
   class Schema

data/lib/graphql/schema/middleware_chain.rb

@@ -71,7 +71,7 @@ module GraphQL
 
       def wrap(callable)
         if BackwardsCompatibility.get_arity(callable) == 6
-          warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
+          GraphQL::Deprecation.warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
           MiddlewareWrapper.new(callable)
         else
           callable

data/lib/graphql/schema/resolver.rb

@@ -276,8 +276,29 @@ module GraphQL
           end
         end
 
+        # Get or set the `max_page_size:` which will be configured for fields using this resolver
+        # (`nil` means "unlimited max page size".)
+        # @param max_page_size [Integer, nil] Set a new value
+        # @return [Integer, nil] The `max_page_size` assigned to fields that use this resolver
+        def max_page_size(new_max_page_size = :not_given)
+          if new_max_page_size != :not_given
+            @max_page_size = new_max_page_size
+          elsif defined?(@max_page_size)
+            @max_page_size
+          elsif superclass.respond_to?(:max_page_size)
+            superclass.max_page_size
+          else
+            nil
+          end
+        end
+
+        # @return [Boolean] `true` if this resolver or a superclass has an assigned `max_page_size`
+        def has_max_page_size?
+          defined?(@max_page_size) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
+        end
+
         def field_options
-          {
+          field_opts = {
             type: type_expr,
             description: description,
             extras: extras,
@@ -289,6 +310,12 @@ module GraphQL
             extensions: extensions,
             broadcastable: broadcastable?,
           }
+
+          if has_max_page_size?
+            field_opts[:max_page_size] = max_page_size
+          end
+
+          field_opts
         end
 
         # A non-normalized type configuration, without `null` applied

data/lib/graphql/schema/timeout_middleware.rb

@@ -30,7 +30,7 @@ module GraphQL
       def initialize(max_seconds:, context_key: nil, &block)
         @max_seconds = max_seconds
         if context_key
-          warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
+          GraphQL::Deprecation.warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
         end
         @error_handler = block
       end

data/lib/graphql/schema/validation.rb

@@ -203,7 +203,7 @@ module GraphQL
         RESERVED_TYPE_NAME = ->(type) {
           if type.name.start_with?('__') && !type.introspection?
             # TODO: make this a hard failure in a later version
-            warn("Name #{type.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
+            GraphQL::Deprecation.warn("Name #{type.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
             nil
           else
             # ok name
@@ -213,7 +213,7 @@ module GraphQL
         RESERVED_NAME = ->(named_thing) {
           if named_thing.name.start_with?('__')
             # TODO: make this a hard failure in a later version
-            warn("Name #{named_thing.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
+            GraphQL::Deprecation.warn("Name #{named_thing.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
             nil
           else
             # no worries

data/lib/graphql/static_validation/validator.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "timeout"
+
 module GraphQL
   module StaticValidation
     # Initialized with a {GraphQL::Schema}, then it can validate {GraphQL::Language::Nodes::Documents}s based on that schema.
@@ -43,8 +45,8 @@ module GraphQL
                 unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
                   legacy_rules.each do |rule_class_or_module|
                     if rule_class_or_module.method_defined?(:validate)
-                      warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
-                      warn "  -> Legacy validator: #{rule_class_or_module}"
+                      GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
+                      GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
                       rule_class_or_module.new.validate(context)
                     end
                   end

data/lib/graphql/subscriptions/event.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # This thing can be:

data/lib/graphql/subscriptions/instrumentation.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # Wrap the root fields of the subscription type with special logic for:

data/lib/graphql/subscriptions/serialize.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 require "set"
 module GraphQL
   class Subscriptions

data/lib/graphql/subscriptions/subscription_root.rb

@@ -6,7 +6,7 @@ module GraphQL
     # @deprecated This module is no longer needed.
     module SubscriptionRoot
       def self.extended(child_cls)
-        warn "`extend GraphQL::Subscriptions::SubscriptionRoot` is no longer required; you can remove it from your Subscription type (#{child_cls})"
+        GraphQL::Deprecation.warn "`extend GraphQL::Subscriptions::SubscriptionRoot` is no longer required; you can remove it from your Subscription type (#{child_cls})"
         child_cls.include(InstanceMethods)
       end
 

data/lib/graphql/tracing/skylight_tracing.rb

@@ -18,7 +18,7 @@ module GraphQL
       #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
       #   It can also be specified per-query with `context[:set_skylight_endpoint_name]`.
       def initialize(options = {})
-        warn("GraphQL::Tracing::SkylightTracing is deprecated and will be removed in GraphQL-Ruby 2.0, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
+        GraphQL::Deprecation.warn("GraphQL::Tracing::SkylightTracing is deprecated and will be removed in GraphQL-Ruby 2.0, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
         @set_endpoint_name = options.fetch(:set_endpoint_name, false)
         super
       end

data/lib/graphql/upgrader/member.rb

@@ -771,7 +771,7 @@ module GraphQL
 
     class Member
       def initialize(member, skip: SkipOnNullKeyword, type_transforms: DEFAULT_TYPE_TRANSFORMS, field_transforms: DEFAULT_FIELD_TRANSFORMS, clean_up_transforms: DEFAULT_CLEAN_UP_TRANSFORMS)
-        warn "#{self.class} will be removed from GraphQL-Ruby 2.0 (but there's no point in using it after you've transformed your code, anyways)"
+        GraphQL::Deprecation.warn "#{self.class} will be removed from GraphQL-Ruby 2.0 (but there's no point in using it after you've transformed your code, anyways)"
         @member = member
         @skip = skip
         @type_transforms = type_transforms