graphql 1.12.3 → 1.12.4

data/lib/graphql/execution/multiplex.rb

@@ -35,7 +35,7 @@ module GraphQL
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
-        @context[:dataloader] = @dataloader = @schema.dataloader_class.new(context)
+        @context[:dataloader] = @dataloader = @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
@@ -74,6 +74,24 @@ module GraphQL
           end
         end
 
+        # @param query [GraphQL::Query]
+        def begin_query(results, idx, query, multiplex)
+          operation = query.selected_operation
+          result = if operation.nil? || !query.valid? || query.context.errors.any?
+            NO_OPERATION
+          else
+            begin
+              # These were checked to be the same in `#supports_multiplexing?`
+              query.schema.query_execution_strategy.begin_query(query, multiplex)
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              NO_OPERATION
+            end
+          end
+          results[idx] = result
+          nil
+        end
+
         private
 
         def run_as_multiplex(multiplex)
@@ -83,15 +101,13 @@ module GraphQL
           # Do as much eager evaluation of the query as possible
           results = []
           queries.each_with_index do |query, idx|
-            multiplex.dataloader.enqueue {
-              results[idx] = begin_query(query, multiplex)
-            }
+            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
           end
 
           multiplex.dataloader.run
 
           # Then, work through lazy results in a breadth-first way
-          multiplex.dataloader.enqueue {
+          multiplex.dataloader.append_job {
             multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
           }
           multiplex.dataloader.run
@@ -112,23 +128,6 @@ module GraphQL
           raise
         end
 
-        # @param query [GraphQL::Query]
-        # @return [Hash] The initial result (may not be finished if there are lazy values)
-        def begin_query(query, multiplex)
-          operation = query.selected_operation
-          if operation.nil? || !query.valid? || query.context.errors.any?
-            NO_OPERATION
-          else
-            begin
-              # These were checked to be the same in `#supports_multiplexing?`
-              query.schema.query_execution_strategy.begin_query(query, multiplex)
-            rescue GraphQL::ExecutionError => err
-              query.context.errors << err
-              NO_OPERATION
-            end
-          end
-        end
-
         # @param data_result [Hash] The result for the "data" key, if any
         # @param query [GraphQL::Query] The query which was run
         # @return [Hash] final result of this query, including all values and errors

data/lib/graphql/object_type.rb

@@ -121,8 +121,6 @@ module GraphQL
           iface = GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
           if iface.is_a?(GraphQL::InterfaceType)
             @clean_inherited_fields.merge!(iface.fields)
-          else
-            pp iface
           end
         end
         @clean_inherited_fields

data/lib/graphql/parse_error.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: language/parser.rb
 module GraphQL
   class ParseError < GraphQL::Error
     attr_reader :line, :col, :query

data/lib/graphql/query.rb

@@ -251,12 +251,18 @@ module GraphQL
     # @param parent_object [GraphQL::Schema::Object]
     # @return Hash{Symbol => Object}
     def arguments_for(ast_node, definition, parent_object: nil)
+      if interpreter?
+        arguments_cache.fetch(ast_node, definition, parent_object)
+      else
+        arguments_cache[ast_node][definition]
+      end
+    end
+
+    def arguments_cache
       if interpreter?
         @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-        @arguments_cache.fetch(ast_node, definition, parent_object)
       else
         @arguments_cache ||= ArgumentsCache.build(self)
-        @arguments_cache[ast_node][definition]
       end
     end
 

data/lib/graphql/query/arguments_cache.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../query.rb
 module GraphQL
   class Query
     module ArgumentsCache

data/lib/graphql/query/context.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../execution/execute.rb
-# test_via: ../execution/lazy.rb
 module GraphQL
   class Query
     # Expose some query-specific info to field resolve functions.
@@ -159,7 +157,7 @@ module GraphQL
       end
 
       def dataloader
-        @dataloader ||= query.multiplex.dataloader
+        @dataloader ||= query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new
       end
 
       # @api private

data/lib/graphql/query/executor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../query.rb
 module GraphQL
   class Query
     class Executor

data/lib/graphql/query/null_context.rb

@@ -9,10 +9,11 @@ module GraphQL
         def visible_type?(t); true; end
       end
 
-      attr_reader :schema, :query, :warden
+      attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
         @query = nil
+        @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = GraphQL::Schema.new
         @warden = NullWarden.new(
           GraphQL::Filter.new,
@@ -36,7 +37,7 @@ module GraphQL
           @instance = self.new
         end
 
-        def_delegators :instance, :query, :schema, :warden, :interpreter?
+        def_delegators :instance, :query, :schema, :warden, :interpreter?, :dataloader
       end
     end
   end

data/lib/graphql/query/variable_validation_error.rb

@@ -23,7 +23,7 @@ module GraphQL
         # a one level deep merge explicitly. However beyond that only show the
         # latest value and problems.
         super.merge({ "extensions" => { "value" => value, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
-          if oldValue.respond_to? merge
+          if oldValue.respond_to?(:merge)
             oldValue.merge(newValue)
           else
             newValue

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)
@@ -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