graphql 2.4.9 → 2.4.11

data/lib/graphql/dataloader/active_record_association_source.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "graphql/dataloader/source"
+require "graphql/dataloader/active_record_source"
+
+module GraphQL
+  class Dataloader
+    class ActiveRecordAssociationSource < GraphQL::Dataloader::Source
+      RECORD_SOURCE_CLASS = ActiveRecordSource
+
+      def initialize(association, scope = nil)
+        @association = association
+        @scope = scope
+      end
+
+      def load(record)
+        if (assoc = record.association(@association)).loaded?
+          assoc.target
+        else
+          super
+        end
+      end
+
+      def fetch(records)
+        record_classes = Set.new.compare_by_identity
+        associated_classes = Set.new.compare_by_identity
+        records.each do |record|
+          if record_classes.add?(record.class)
+            reflection = record.class.reflect_on_association(@association)
+            if !reflection.polymorphic? && reflection.klass
+              associated_classes.add(reflection.klass)
+            end
+          end
+        end
+
+        available_records = []
+        associated_classes.each do |assoc_class|
+          already_loaded_records = dataloader.with(RECORD_SOURCE_CLASS, assoc_class).results.values
+          available_records.concat(already_loaded_records)
+        end
+
+        ::ActiveRecord::Associations::Preloader.new(records: records, associations: @association, available_records: available_records, scope: @scope).call
+
+        loaded_associated_records = records.map { |r| r.public_send(@association) }
+        records_by_model = {}
+        loaded_associated_records.each do |record|
+          if record
+            updates = records_by_model[record.class] ||= {}
+            updates[record.id] = record
+          end
+        end
+
+        if @scope.nil?
+          # Don't cache records loaded via scope because they might have reduced `SELECT`s
+          # Could check .select_values here?
+          records_by_model.each do |model_class, updates|
+            dataloader.with(RECORD_SOURCE_CLASS, model_class).merge(updates)
+          end
+        end
+
+        loaded_associated_records
+      end
+    end
+  end
+end

data/lib/graphql/dataloader/active_record_source.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require "graphql/dataloader/source"
+
+module GraphQL
+  class Dataloader
+    class ActiveRecordSource < GraphQL::Dataloader::Source
+      def initialize(model_class, find_by: model_class.primary_key)
+        @model_class = model_class
+        @find_by = find_by
+        @type_for_column = @model_class.type_for_attribute(@find_by)
+      end
+
+      def load(requested_key)
+        casted_key = @type_for_column.cast(requested_key)
+        super(casted_key)
+      end
+
+      def fetch(record_ids)
+        records = @model_class.where(@find_by => record_ids)
+        record_lookup = {}
+        records.each { |r| record_lookup[r.public_send(@find_by)] = r }
+        record_ids.map { |id| record_lookup[id] }
+      end
+    end
+  end
+end

data/lib/graphql/dataloader/async_dataloader.rb

@@ -2,16 +2,20 @@
 module GraphQL
   class Dataloader
     class AsyncDataloader < Dataloader
-      def yield
+      def yield(source = Fiber[:__graphql_current_dataloader_source])
+        trace = Fiber[:__graphql_current_multiplex]&.current_trace
+        trace&.dataloader_fiber_yield(source)
         if (condition = Fiber[:graphql_dataloader_next_tick])
           condition.wait
         else
           Fiber.yield
         end
+        trace&.dataloader_fiber_resume(source)
         nil
       end
 
       def run
+        trace = Fiber[:__graphql_current_multiplex]&.current_trace
         jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
         job_fibers = []
         next_job_fibers = []
@@ -20,11 +24,12 @@ module GraphQL
         first_pass = true
         sources_condition = Async::Condition.new
         manager = spawn_fiber do
+          trace&.begin_dataloader(self)
           while first_pass || !job_fibers.empty?
             first_pass = false
             fiber_vars = get_fiber_variables
 
-            while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber)))
+            while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
               if f.alive?
                 finished = run_fiber(f)
                 if !finished
@@ -38,7 +43,7 @@ module GraphQL
             Sync do |root_task|
               set_fiber_variables(fiber_vars)
               while !source_tasks.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
-                while (task = (source_tasks.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size + next_source_tasks.size) < total_fiber_limit) && spawn_source_task(root_task, sources_condition))))
+                while (task = (source_tasks.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size + next_source_tasks.size) < total_fiber_limit) && spawn_source_task(root_task, sources_condition, trace))))
                   if task.alive?
                     root_task.yield # give the source task a chance to run
                     next_source_tasks << task
@@ -50,6 +55,7 @@ module GraphQL
               end
             end
           end
+          trace&.end_dataloader(self)
         end
 
         manager.resume
@@ -63,7 +69,7 @@ module GraphQL
 
       private
 
-      def spawn_source_task(parent_task, condition)
+      def spawn_source_task(parent_task, condition, trace)
         pending_sources = nil
         @source_cache.each_value do |source_by_batch_params|
           source_by_batch_params.each_value do |source|
@@ -77,10 +83,16 @@ module GraphQL
         if pending_sources
           fiber_vars = get_fiber_variables
           parent_task.async do
+            trace&.dataloader_spawn_source_fiber(pending_sources)
             set_fiber_variables(fiber_vars)
             Fiber[:graphql_dataloader_next_tick] = condition
-            pending_sources.each(&:run_pending_keys)
+            pending_sources.each do |s|
+              trace&.begin_dataloader_source(s)
+              s.run_pending_keys
+              trace&.end_dataloader_source(s)
+            end
             cleanup_fiber
+            trace&.dataloader_fiber_exit
           end
         end
       end

data/lib/graphql/dataloader/null_dataloader.rb

@@ -11,7 +11,7 @@ module GraphQL
       # executed synchronously.
       def run; end
       def run_isolated; yield; end
-      def yield
+      def yield(_source)
         raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
       end
 

data/lib/graphql/dataloader/source.rb

@@ -93,14 +93,14 @@ module GraphQL
       # Then run the batch and update the cache.
       # @return [void]
       def sync(pending_result_keys)
-        @dataloader.yield
+        @dataloader.yield(self)
         iterations = 0
         while pending_result_keys.any? { |key| !@results.key?(key) }
           iterations += 1
           if iterations > MAX_ITERATIONS
             raise "#{self.class}#sync tried #{MAX_ITERATIONS} times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency#{@dataloader.fiber_limit ? " or `fiber_limit: #{@dataloader.fiber_limit}` is set too low" : ""}."
           end
-          @dataloader.yield
+          @dataloader.yield(self)
         end
         nil
       end

data/lib/graphql/dataloader.rb

@@ -4,6 +4,8 @@ require "graphql/dataloader/null_dataloader"
 require "graphql/dataloader/request"
 require "graphql/dataloader/request_all"
 require "graphql/dataloader/source"
+require "graphql/dataloader/active_record_association_source"
+require "graphql/dataloader/active_record_source"
 
 module GraphQL
   # This plugin supports Fiber-based concurrency, along with {GraphQL::Dataloader::Source}.
@@ -129,8 +131,11 @@ module GraphQL
     # Dataloader will resume the fiber after the requested data has been loaded (by another Fiber).
     #
     # @return [void]
-    def yield
+    def yield(source = Fiber[:__graphql_current_dataloader_source])
+      trace = Fiber[:__graphql_current_multiplex]&.current_trace
+      trace&.dataloader_fiber_yield(source)
       Fiber.yield
+      trace&.dataloader_fiber_resume(source)
       nil
     end
 
@@ -184,6 +189,7 @@ module GraphQL
     end
 
     def run
+      trace = Fiber[:__graphql_current_multiplex]&.current_trace
       jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []
       next_job_fibers = []
@@ -191,10 +197,11 @@ module GraphQL
       next_source_fibers = []
       first_pass = true
       manager = spawn_fiber do
+        trace&.begin_dataloader(self)
         while first_pass || !job_fibers.empty?
           first_pass = false
 
-          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber)))
+          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
             if f.alive?
               finished = run_fiber(f)
               if !finished
@@ -205,7 +212,7 @@ module GraphQL
           join_queues(job_fibers, next_job_fibers)
 
           while (!source_fibers.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
-            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber))
+            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
               if f.alive?
                 finished = run_fiber(f)
                 if !finished
@@ -216,6 +223,8 @@ module GraphQL
             join_queues(source_fibers, next_source_fibers)
           end
         end
+
+        trace&.end_dataloader(self)
       end
 
       run_fiber(manager)
@@ -230,6 +239,7 @@ module GraphQL
       if !source_fibers.empty?
         raise "Invariant: source fibers should have exited but #{source_fibers.size} remained"
       end
+
     rescue UncaughtThrowError => e
       throw e.tag, e.value
     end
@@ -247,6 +257,22 @@ module GraphQL
       }
     end
 
+    # Pre-warm the Dataloader cache with ActiveRecord objects which were loaded elsewhere.
+    # These will be used by {Dataloader::ActiveRecordSource}, {Dataloader::ActiveRecordAssociationSource} and their helper
+    # methods, `dataload_record` and `dataload_association`.
+    # @param records [Array<ActiveRecord::Base>] Already-loaded records to warm the cache with
+    # @param index_by [Symbol] The attribute to use as the cache key. (Should match `find_by:` when using {ActiveRecordSource})
+    # @return [void]
+    def merge_records(records, index_by: :id)
+      records_by_class = Hash.new { |h, k| h[k] = {} }
+      records.each do |r|
+        records_by_class[r.class][r.public_send(index_by)] = r
+      end
+      records_by_class.each do |r_class, records|
+        with(ActiveRecordSource, r_class).merge(records)
+      end
+    end
+
     private
 
     def calculate_fiber_limit
@@ -266,17 +292,19 @@ module GraphQL
       new_queue.clear
     end
 
-    def spawn_job_fiber
+    def spawn_job_fiber(trace)
       if !@pending_jobs.empty?
         spawn_fiber do
+          trace&.dataloader_spawn_execution_fiber(@pending_jobs)
           while job = @pending_jobs.shift
             job.call
           end
+          trace&.dataloader_fiber_exit
         end
       end
     end
 
-    def spawn_source_fiber
+    def spawn_source_fiber(trace)
       pending_sources = nil
       @source_cache.each_value do |source_by_batch_params|
         source_by_batch_params.each_value do |source|
@@ -289,10 +317,14 @@ module GraphQL
 
       if pending_sources
         spawn_fiber do
+          trace&.dataloader_spawn_source_fiber(pending_sources)
           pending_sources.each do |source|
             Fiber[:__graphql_current_dataloader_source] = source
+            trace&.begin_dataloader_source(source)
             source.run_pending_keys
+            trace&.end_dataloader_source(source)
           end
+          trace&.dataloader_fiber_exit
         end
       end
     end

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

@@ -218,8 +218,10 @@ module GraphQL
                     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)
+                  if finished_jobs == enqueued_jobs
+                    if target_result
+                      selections_result.merge_into(target_result)
+                    end
                   end
                   @dataloader.clear_cache
                 }
@@ -229,8 +231,10 @@ module GraphQL
                     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)
+                  if finished_jobs == enqueued_jobs
+                    if target_result
+                      selections_result.merge_into(target_result)
+                    end
                   end
                 }
               end
@@ -371,6 +375,7 @@ module GraphQL
             end
             # Actually call the field resolver and capture the result
             app_result = begin
+              @current_trace.begin_execute_field(field_defn, object, kwarg_arguments, query)
               @current_trace.execute_field(field: field_defn, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments) do
                 field_defn.resolve(object, kwarg_arguments, context)
               end
@@ -383,6 +388,7 @@ module GraphQL
                 ex_err
               end
             end
+            @current_trace.end_execute_field(field_defn, object, kwarg_arguments, query, app_result)
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
               owner_type = selection_result.graphql_result_type
               return_type = field_defn.type
@@ -391,6 +397,8 @@ module GraphQL
                 was_scoped = runtime_state.was_authorized_by_scope_items
                 runtime_state.was_authorized_by_scope_items = nil
                 continue_field(continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result, was_scoped, runtime_state)
+              else
+                nil
               end
             end
           end
@@ -465,7 +473,7 @@ module GraphQL
                 # When this comes from a list item, use the parent object:
                 parent_type = selection_result.is_a?(GraphQLResultArray) ? selection_result.graphql_parent.graphql_result_type : selection_result.graphql_result_type
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
-                err = parent_type::InvalidNullError.new(parent_type, field, value)
+                err = parent_type::InvalidNullError.new(parent_type, field, value, ast_node)
                 schema.type_error(err, context)
               end
             else
@@ -781,8 +789,10 @@ module GraphQL
               runtime_state.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
+              result = nil
               inner_obj = begin
-                if trace
+                result = if trace
+                  @current_trace.begin_execute_field(field, owner_object, arguments, query)
                   @current_trace.execute_field_lazy(field: field, query: query, object: owner_object, arguments: arguments, ast_node: ast_node) do
                     schema.sync_lazy(lazy_obj)
                   end
@@ -797,6 +807,10 @@ module GraphQL
                 rescue GraphQL::ExecutionError => ex_err
                   ex_err
                 end
+              ensure
+                if trace
+                  @current_trace.end_execute_field(field, owner_object, arguments, query, result)
+                end
               end
               yield(inner_obj, runtime_state)
             end
@@ -840,14 +854,19 @@ module GraphQL
         end
 
         def resolve_type(type, value)
+          @current_trace.begin_resolve_type(type, value, context)
           resolved_type, resolved_value = @current_trace.resolve_type(query: query, type: type, object: value) do
             query.resolve_type(type, value)
           end
+          @current_trace.end_resolve_type(type, value, context, resolved_type)
 
           if lazy?(resolved_type)
             GraphQL::Execution::Lazy.new do
+              @current_trace.begin_resolve_type(type, value, context)
               @current_trace.resolve_type_lazy(query: query, type: type, object: value) do
-                schema.sync_lazy(resolved_type)
+                rt = schema.sync_lazy(resolved_type)
+                @current_trace.end_resolve_type(type, value, context, rt)
+                rt
               end
             end
           else

data/lib/graphql/execution/interpreter.rb

@@ -33,9 +33,12 @@ module GraphQL
             end
           end
 
+
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
           Fiber[:__graphql_current_multiplex] = multiplex
-          multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
+          trace = multiplex.current_trace
+          trace.begin_execute_multiplex(multiplex)
+          trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
@@ -44,7 +47,10 @@ module GraphQL
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
             end
 
+            trace.begin_analyze_multiplex(multiplex, multiplex_analyzers)
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            trace.end_analyze_multiplex(multiplex, multiplex_analyzers)
+
             begin
               # Since this is basically the batching context,
               # share it for a whole multiplex
@@ -148,6 +154,8 @@ module GraphQL
               }
             end
           end
+        ensure
+          trace&.end_execute_multiplex(multiplex)
         end
       end
 

data/lib/graphql/invalid_name_error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  class InvalidNameError < GraphQL::ExecutionError
+  class InvalidNameError < GraphQL::Error
     attr_reader :name, :valid_regex
     def initialize(name, valid_regex)
       @name = name

data/lib/graphql/invalid_null_error.rb

@@ -2,7 +2,7 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::RuntimeTypeError
+  class InvalidNullError < GraphQL::Error
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
@@ -12,23 +12,17 @@ module GraphQL
     # @return [nil, GraphQL::ExecutionError] The invalid value for this field
     attr_reader :value
 
-    def initialize(parent_type, field, value)
+    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
+    attr_reader :ast_node
+
+    def initialize(parent_type, field, value, ast_node)
       @parent_type = parent_type
       @field = field
       @value = value
+      @ast_node = ast_node
       super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
     end
 
-    # @return [Hash] An entry for the response's "errors" key
-    def to_h
-      { "message" => message }
-    end
-
-    # @deprecated always false
-    def parent_error?
-      false
-    end
-
     class << self
       attr_accessor :parent_class
 

data/lib/graphql/language/parser.rb

@@ -161,7 +161,7 @@ module GraphQL
               expect_token(:VAR_SIGN)
               var_name = parse_name
               expect_token(:COLON)
-              var_type = self.type
+              var_type = self.type || raise_parse_error("Missing type definition for variable: $#{var_name}")
               default_value = if at?(:EQUALS)
                 advance_token
                 value

data/lib/graphql/query.rb

@@ -97,21 +97,22 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    # @param visibility_profile [Symbol]
+    # @param visibility_profile [Symbol] Another way to assign `context[:visibility_profile]`
     def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, visibility_profile: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_visibility_profile: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
       @context = schema.context_class.new(query: self, values: context)
+      if visibility_profile
+        @context[:visibility_profile] ||= visibility_profile
+      end
 
       if use_visibility_profile.nil?
         use_visibility_profile = warden ? false : schema.use_visibility_profile?
       end
 
-      @visibility_profile = visibility_profile
-
       if use_visibility_profile
-        @visibility_profile = @schema.visibility.profile_for(@context, visibility_profile)
+        @visibility_profile = @schema.visibility.profile_for(@context)
         @warden = Schema::Warden::NullWarden.new(context: @context, schema: @schema)
       else
         @visibility_profile = nil
@@ -440,6 +441,7 @@ module GraphQL
       @warden ||= @schema.warden_class.new(schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
+        current_trace.begin_parse(query_string)
         if query_string
           GraphQL.parse(query_string, trace: self.current_trace, max_tokens: @schema.max_query_string_tokens)
         end
@@ -447,6 +449,8 @@ module GraphQL
         parse_error = err
         @schema.parse_error(err, @context)
         nil
+      ensure
+        current_trace.end_parse(query_string)
       end
 
       @fragments = {}

data/lib/graphql/schema/build_from_definition.rb

@@ -298,7 +298,6 @@ module GraphQL
                 description: enum_value_definition.description,
                 directives: builder.prepare_directives(enum_value_definition, type_resolver),
                 ast_node: enum_value_definition,
-                value_method: GraphQL::Schema::Enum.respond_to?(enum_value_definition.name.downcase) ? false : nil,
               )
             end
           end

data/lib/graphql/schema/enum.rb

@@ -70,7 +70,9 @@ module GraphQL
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
 
-          generate_value_method(value, value_method)
+          if value_method || (value_methods && value_method != false)
+            generate_value_method(value, value_method)
+          end
 
           key = value.graphql_name
           prev_value = own_values[key]
@@ -159,6 +161,18 @@ module GraphQL
           end
         end
 
+        def value_methods(new_value = NOT_CONFIGURED)
+          if NOT_CONFIGURED.equal?(new_value)
+            if @value_methods != nil
+              @value_methods
+            else
+              find_inherited_value(:value_methods, false)
+            end
+          else
+            @value_methods = new_value
+          end
+        end
+
         def kind
           GraphQL::TypeKinds::ENUM
         end
@@ -220,6 +234,7 @@ module GraphQL
             # because they would end up with names like `#<Class0x1234>::UnresolvedValueError` which messes up bug trackers
             child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
           end
+          child_class.class_eval { @value_methods = nil }
           super
         end
 
@@ -241,7 +256,7 @@ module GraphQL
             return
           end
 
-          instance_eval("def #{value_method_name}; #{value.graphql_name.inspect}; end;")
+          instance_eval("def #{value_method_name}; #{value.graphql_name.inspect}; end;", __FILE__, __LINE__)
         end
       end
 

data/lib/graphql/schema/input_object.rb

@@ -156,7 +156,7 @@ module GraphQL
               def #{method_name}
                 self[#{method_name.inspect}]
               end
-              alias_method :#{method_name}, :#{method_name}
+              alias_method #{method_name.inspect}, #{method_name.inspect}
             RUBY
           end
           argument_defn

data/lib/graphql/schema/interface.rb

@@ -13,6 +13,7 @@ module GraphQL
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
         include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDataloader
         include GraphQL::Schema::Member::HasDirectives
         include GraphQL::Schema::Member::HasInterfaces