graphql 1.10.7 → 1.10.12

data/lib/graphql/object_type.rb

@@ -88,7 +88,7 @@ module GraphQL
       interfaces.each do |iface|
         iface = BaseType.resolve_related_type(iface)
         if iface.is_a?(GraphQL::InterfaceType)
-          type_memberships << iface.type_membership_class.new(iface, self, options)
+          type_memberships << iface.type_membership_class.new(iface, self, **options)
         end
       end
     end

data/lib/graphql/relay/base_connection.rb

@@ -74,8 +74,6 @@ module GraphQL
 
       def decode(data)
         @encoder.decode(data, nonce: true)
-      rescue ArgumentError
-        raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
       end
 
       # The value passed as `first:`, if there was one. Negative numbers become `0`.

data/lib/graphql/schema.rb

@@ -101,14 +101,12 @@ module GraphQL
       # - Right away, if `value` is not registered with `lazy_resolve`
       # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
       # @api private
-      def after_lazy(value)
+      def after_lazy(value, &block)
         if lazy?(value)
           GraphQL::Execution::Lazy.new do
             result = sync_lazy(value)
             # The returned result might also be lazy, so check it, too
-            after_lazy(result) do |final_result|
-              yield(final_result) if block_given?
-            end
+            after_lazy(result, &block)
           end
         else
           yield(value) if block_given?
@@ -146,10 +144,10 @@ module GraphQL
       def after_any_lazies(maybe_lazies)
         if maybe_lazies.any? { |l| lazy?(l) }
           GraphQL::Execution::Lazy.all(maybe_lazies).then do |result|
-            yield
+            yield result
           end
         else
-          yield
+          yield maybe_lazies
         end
       end
     end
@@ -872,8 +870,8 @@ module GraphQL
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
-      def to_json(*args)
-        JSON.pretty_generate(as_json(*args))
+      def to_json(**args)
+        JSON.pretty_generate(as_json(**args))
       end
 
       # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
@@ -1391,7 +1389,7 @@ module GraphQL
       # rubocop:disable Lint/DuplicateMethods
       module ResolveTypeWithType
         def resolve_type(type, obj, ctx)
-          first_resolved_type = if type.is_a?(Module) && type.respond_to?(:resolve_type)
+          first_resolved_type, resolved_value = if type.is_a?(Module) && type.respond_to?(:resolve_type)
             type.resolve_type(obj, ctx)
           else
             super
@@ -1399,7 +1397,11 @@ module GraphQL
 
           after_lazy(first_resolved_type) do |resolved_type|
             if resolved_type.nil? || (resolved_type.is_a?(Module) && resolved_type.respond_to?(:kind)) || resolved_type.is_a?(GraphQL::BaseType)
-              resolved_type
+              if resolved_value
+                [resolved_type, resolved_value]
+              else
+                resolved_type
+              end
             else
               raise ".resolve_type should return a type definition, but got #{resolved_type.inspect} (#{resolved_type.class}) from `resolve_type(#{type}, #{obj}, #{ctx})`"
             end
@@ -1508,7 +1510,11 @@ module GraphQL
 
       # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
       def error_handler
-        @error_handler ||= GraphQL::Execution::Errors::NullErrorHandler
+        if defined?(@error_handler)
+          @error_handler
+        else
+          find_inherited_value(:error_handler, GraphQL::Execution::Errors::NullErrorHandler)
+        end
       end
 
       def lazy_resolve(lazy_class, value_method)

data/lib/graphql/schema/argument.rb

@@ -154,6 +154,12 @@ module GraphQL
         raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
       end
 
+      def statically_coercible?
+        return @statically_coercible if defined?(@statically_coercible)
+
+        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+      end
+
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private

data/lib/graphql/schema/base_64_encoder.rb

@@ -13,6 +13,8 @@ module GraphQL
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
         Base64Bp.urlsafe_decode64(encoded_text)
+      rescue ArgumentError
+        raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end
     end
   end

data/lib/graphql/schema/enum.rb

@@ -23,6 +23,9 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
+      class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+      end
+
       class << self
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
@@ -94,7 +97,7 @@ module GraphQL
           if enum_value
             enum_value.graphql_name
           else
-            raise(GraphQL::EnumType::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+            raise(self::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
           end
         end
 
@@ -112,6 +115,11 @@ module GraphQL
           end
         end
 
+        def inherited(child_class)
+          child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
+          super
+        end
+
         private
 
         def own_values

data/lib/graphql/schema/field.rb

@@ -47,6 +47,11 @@ module GraphQL
         @resolver_class
       end
 
+      # @return [Boolean] Is this field a predefined introspection field?
+      def introspection?
+        @introspection
+      end
+
       alias :mutation :resolver
 
       # @return [Boolean] Apply tracing to this field? (Default: skip scalars, this is the override value)
@@ -551,34 +556,36 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
-          if self.authorized?(application_object, args, ctx)
-            # Apply field extensions
-            with_extensions(object, args, ctx) do |extended_obj, extended_args|
-              field_receiver = if @resolver_class
-                resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
-                  extended_obj.object
+          ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
+            if is_authorized
+              # Apply field extensions
+              with_extensions(object, args, ctx) do |extended_obj, extended_args|
+                field_receiver = if @resolver_class
+                  resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
+                    extended_obj.object
+                  else
+                    extended_obj
+                  end
+                  @resolver_class.new(object: resolver_obj, context: ctx, field: self)
                 else
                   extended_obj
                 end
-                @resolver_class.new(object: resolver_obj, context: ctx, field: self)
-              else
-                extended_obj
-              end
 
-              if field_receiver.respond_to?(@resolver_method)
-                # Call the method with kwargs, if there are any
-                if extended_args.any?
-                  field_receiver.public_send(@resolver_method, **extended_args)
+                if field_receiver.respond_to?(@resolver_method)
+                  # Call the method with kwargs, if there are any
+                  if extended_args.any?
+                    field_receiver.public_send(@resolver_method, **extended_args)
+                  else
+                    field_receiver.public_send(@resolver_method)
+                  end
                 else
-                  field_receiver.public_send(@resolver_method)
+                  resolve_field_method(field_receiver, extended_args, ctx)
                 end
-              else
-                resolve_field_method(field_receiver, extended_args, ctx)
               end
+            else
+              err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+              ctx.schema.unauthorized_field(err)
             end
-          else
-            err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
-            ctx.schema.unauthorized_field(err)
           end
         rescue GraphQL::UnauthorizedFieldError => err
           err.field ||= self
@@ -663,10 +670,12 @@ module GraphQL
               loaded_value = if loads && !arg_defn.from_resolver?
                 if arg_defn.type.list?
                   loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
-                  maybe_lazies.concat(loaded_values)
+                  field_ctx.schema.after_any_lazies(loaded_values) { |result| result }
                 else
                   load_application_object(arg_defn, loads, value, field_ctx.query.context)
                 end
+              elsif arg_defn.type.list? && value.is_a?(Array)
+                field_ctx.schema.after_any_lazies(value, &:itself)
               else
                 value
               end

data/lib/graphql/schema/input_object.rb

@@ -10,20 +10,19 @@ module GraphQL
 
       include GraphQL::Dig
 
-      def initialize(values = nil, ruby_kwargs: nil, context:, defaults_used:)
+      def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
         if ruby_kwargs
           @ruby_style_hash = ruby_kwargs
+          @arguments = arguments
         else
-          @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
+          @arguments = self.class.arguments_class.new(arguments, context: context, defaults_used: defaults_used)
           # Symbolized, underscored hash:
           @ruby_style_hash = @arguments.to_kwargs
         end
         # Apply prepares, not great to have it duplicated here.
-        @arguments_by_keyword = {}
         maybe_lazies = []
-        self.class.arguments.each do |name, arg_defn|
-          @arguments_by_keyword[arg_defn.keyword] = arg_defn
+        self.class.arguments.each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
 
           if @ruby_style_hash.key?(ruby_kwargs_key)
@@ -56,7 +55,7 @@ module GraphQL
       # @return [GraphQL::Query::Context] The context for this query
       attr_reader :context
 
-      # @return [GraphQL::Query::Arguments] The underlying arguments instance
+      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
       attr_reader :arguments
 
       # Ruby-like hash behaviors, read-only
@@ -208,10 +207,12 @@ module GraphQL
             return nil
           end
 
-          input_values = coerce_arguments(nil, value, ctx)
+          arguments = coerce_arguments(nil, value, ctx)
 
-          input_obj_instance = self.new(ruby_kwargs: input_values, context: ctx, defaults_used: nil)
-          input_obj_instance.prepare
+          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
+          end
         end
 
         # It's funny to think of a _result_ of an input object.

data/lib/graphql/schema/interface.rb

@@ -14,6 +14,7 @@ module GraphQL
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
+        include GraphQL::Schema::Member::HasUnresolvedTypeError
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -74,6 +75,10 @@ module GraphQL
             if overridden_graphql_name
               child_class.graphql_name(overridden_graphql_name)
             end
+            # If interfaces are mixed into each other, only define this class once
+            if !child_class.const_defined?(:UnresolvedTypeError, false)
+              add_unresolved_type_error(child_class)
+            end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
             backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}

data/lib/graphql/schema/list.rb

@@ -44,7 +44,8 @@ module GraphQL
         if value.nil?
           nil
         else
-          ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          coerced = ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          ctx.schema.after_any_lazies(coerced, &:itself)
         end
       end
 

data/lib/graphql/schema/loader.rb

@@ -157,6 +157,7 @@ module GraphQL
               type: type_resolver.call(field_hash["type"]),
               description: field_hash["description"],
               null: true,
+              camelize: false,
             ) do
               if field_hash["args"].any?
                 loader.build_arguments(self, field_hash["args"], type_resolver)
@@ -171,6 +172,8 @@ module GraphQL
               type: type_resolver.call(arg["type"]),
               description: arg["description"],
               required: false,
+              method_access: false,
+              camelize: false,
             }
 
             if arg["defaultValue"]

data/lib/graphql/schema/member.rb

@@ -5,6 +5,7 @@ require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_path'
+require 'graphql/schema/member/has_unresolved_type_error'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'

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

@@ -63,10 +63,12 @@ module GraphQL
           self.class.argument_class(new_arg_class)
         end
 
+        # @api private
         # @param values [Hash<String, Object>]
         # @param context [GraphQL::Query::Context]
-        # @return Hash<Symbol, Object>
+        # @return [Hash<Symbol, Object>, Execution::Lazy<Hash>]
         def coerce_arguments(parent_object, values, context)
+          argument_values = {}
           kwarg_arguments = {}
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
@@ -75,6 +77,7 @@ module GraphQL
           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]
@@ -84,6 +87,7 @@ module GraphQL
             elsif arg_defn.default_value?
               has_value = true
               value = arg_defn.default_value
+              default_used = true
             end
 
             if has_value
@@ -91,36 +95,52 @@ module GraphQL
               loaded_value = nil
               if loads && !arg_defn.from_resolver?
                 loaded_value = if arg_defn.type.list?
-                  value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                  context.schema.after_any_lazies(loaded_values) { |result| result }
                 else
                   load_application_object(arg_defn, loads, value, context)
                 end
               end
 
-              context.schema.after_lazy(loaded_value) do |loaded_value|
-                coerced_value = nil
-                prepared_value = context.schema.error_handler.with_error_handling(context) do
-
-                  coerced_value = if loaded_value
-                    loaded_value
-                  else
-                    arg_defn.type.coerce_input(value, context)
-                  end
+              coerced_value = if loaded_value
+                loaded_value
+              else
+                context.schema.error_handler.with_error_handling(context) do
+                  arg_defn.type.coerce_input(value, context)
+                end
+              end
 
+              context.schema.after_lazy(coerced_value) do |coerced_value|
+                prepared_value = context.schema.error_handler.with_error_handling(context) do
                   arg_defn.prepare_value(parent_object, coerced_value, context: context)
                 end
 
-                kwarg_arguments[arg_defn.keyword] = prepared_value
+                kwarg_arguments[arg_key] = prepared_value
+                # 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
             end
           end
 
           maybe_lazies.concat(arg_lazies)
           context.schema.after_any_lazies(maybe_lazies) do
-            kwarg_arguments
+            GraphQL::Execution::Interpreter::Arguments.new(
+              keyword_arguments: kwarg_arguments,
+              argument_values: argument_values,
+            )
           end
         end
 
+        def arguments_statically_coercible?
+          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
+
+          @arguments_statically_coercible = arguments.each_value.all?(&:statically_coercible?)
+        end
+
         module ArgumentClassAccessor
           def argument_class(new_arg_class = nil)
             if new_arg_class

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

@@ -47,7 +47,7 @@ module GraphQL
         # A list of GraphQL-Ruby keywords.
         #
         # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method]
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method, :raw_value]
 
         # A list of field names that we should advise users to pick a different
         # resolve method name.

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Set up a type-specific error to make debugging & bug tracker integration better
+      module HasUnresolvedTypeError
+        private
+        def add_unresolved_type_error(child_class)
+          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+        end
+      end
+    end
+  end
+end