graphql 1.12.1 → 1.12.6

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
@@ -156,7 +155,7 @@ module GraphQL
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
-          warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
+          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
 
           query.result_values = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors

data/lib/graphql/function.rb

@@ -3,7 +3,7 @@ module GraphQL
   # @api deprecated
   class Function
     def self.inherited(subclass)
-      warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
+      GraphQL::Deprecation.warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
     end
 
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name

data/lib/graphql/internal_representation/document.rb

@@ -14,12 +14,12 @@ module GraphQL
       end
 
       def [](key)
-        warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
+        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
         operation_definitions[key]
       end
 
       def each(&block)
-        warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
+        GraphQL::Deprecation.warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
         operation_definitions.each(&block)
       end
     end

data/lib/graphql/internal_representation/rewrite.rb

@@ -60,7 +60,7 @@ module GraphQL
 
       # @return [Hash<String, Node>] Roots of this query
       def operations
-        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
+        GraphQL::Deprecation.warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
         @document.operation_definitions
       end
 

data/lib/graphql/language.rb

@@ -6,6 +6,7 @@ require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"
+require "graphql/language/cache"
 require "graphql/language/parser"
 require "graphql/language/token"
 require "graphql/language/visitor"

data/lib/graphql/language/cache.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'graphql/version'
+require 'digest/sha2'
+
+module GraphQL
+  module Language
+    class Cache
+      def initialize(path)
+        @path = path
+      end
+
+      DIGEST = Digest::SHA256.new << GraphQL::VERSION
+      def fetch(filename)
+        hash = DIGEST.dup << filename
+        begin
+          hash << File.mtime(filename).to_i.to_s
+        rescue SystemCallError
+          return yield
+        end
+        cache_path = @path.join(hash.to_s)
+
+        if cache_path.exist?
+          Marshal.load(cache_path.read)
+        else
+          payload = yield
+          tmp_path = "#{cache_path}.#{rand}"
+
+          @path.mkpath
+          File.binwrite(tmp_path, Marshal.dump(payload))
+          File.rename(tmp_path, cache_path.to_s)
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language/parser.rb

@@ -41,12 +41,22 @@ def parse_document
   end
 end
 
-def self.parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
-  self.new(query_string, filename: filename, tracer: tracer).parse_document
-end
+class << self
+  attr_accessor :cache
+
+  def parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
+    new(query_string, filename: filename, tracer: tracer).parse_document
+  end
 
-def self.parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
-  self.parse(File.read(filename), filename: filename, tracer: tracer)
+  def parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
+    if cache
+      cache.fetch(filename) do
+        parse(File.read(filename), filename: filename, tracer: tracer)
+      end
+    else
+      parse(File.read(filename), filename: filename, tracer: tracer)
+    end
+  end
 end
 
 private

data/lib/graphql/language/parser.y

@@ -462,12 +462,22 @@ def parse_document
   end
 end
 
-def self.parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
-  self.new(query_string, filename: filename, tracer: tracer).parse_document
-end
+class << self
+  attr_accessor :cache
+
+  def parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
+    new(query_string, filename: filename, tracer: tracer).parse_document
+  end
 
-def self.parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
-  self.parse(File.read(filename), filename: filename, tracer: tracer)
+  def parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
+    if cache
+      cache.fetch(filename) do
+        parse(File.read(filename), filename: filename, tracer: tracer)
+      end
+    else
+      parse(File.read(filename), filename: filename, tracer: tracer)
+    end
+  end
 end
 
 private

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/pagination/connection.rb

@@ -45,6 +45,9 @@ module GraphQL
         end
       end
 
+      # @return [Hash<Symbol => Object>] The field arguments from the field that returned this connection
+      attr_accessor :arguments
+
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
       # @param context [Query::Context]
       # @param parent [Object] The object this collection belongs to
@@ -52,8 +55,9 @@ module GraphQL
       # @param after [String, nil] A cursor for pagination, if the client provided one
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
+      # @param arguments [Hash] The arguments to the field that returned the collection wrapped by this connection
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil)
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
         @parent = parent
         @context = context
@@ -62,6 +66,7 @@ module GraphQL
         @after_value = after
         @last_value = last
         @before_value = before
+        @arguments = arguments
         @edge_class = edge_class || self.class::Edge
         # This is only true if the object was _initialized_ with an override
         # or if one is assigned later.
@@ -105,6 +110,15 @@ module GraphQL
         end
       end
 
+      # This is called by `Relay::RangeAdd` -- it can be overridden
+      # when `item` needs some modifications based on this connection's state.
+      #
+      # @param item [Object] An item newly added to `items`
+      # @return [Edge]
+      def range_add_edge(item)
+        edge_class.new(item, self)
+      end
+
       attr_writer :last
       # @return [Integer, nil] A clamped `last` value. (The underlying instance variable doesn't have limits on it)
       def last

data/lib/graphql/pagination/connections.rb

@@ -23,7 +23,7 @@ module GraphQL
 
       def self.use(schema_defn)
         if schema_defn.plugins.any? { |(plugin, args)| plugin == self }
-          warn("#{self} is now the default, remove `use #{self}` from #{caller(2,1).first}")
+          GraphQL::Deprecation.warn("#{self} is now the default, remove `use #{self}` from #{caller(2,1).first}")
         end
         schema_defn.connections = self.new(schema: schema_defn)
       end
@@ -84,6 +84,7 @@ module GraphQL
           after: arguments[:after],
           last: arguments[:last],
           before: arguments[:before],
+          arguments: arguments,
           edge_class: edge_class_for_field(field),
         )
       end

data/lib/graphql/pagination/relation_connection.rb

@@ -32,7 +32,11 @@ module GraphQL
           @has_next_page = if before_offset && before_offset > 0
             true
           elsif first
-            relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
+            if @nodes && @nodes.count < first
+              false
+            else
+              relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
+            end
           else
             false
           end

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.rb

@@ -22,7 +22,7 @@ module GraphQL
               method_names.each do |method_name|
                 # Don't define a helper method if it would override something.
                 if method_defined?(method_name)
-                  warn(
+                  GraphQL::Deprecation.warn(
                     "Unable to define a helper for argument with name '#{method_name}' "\
                     "as this is a reserved name. Add `method_access: false` to stop this warning."
                   )

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/serial_execution.rb

@@ -16,7 +16,7 @@ module GraphQL
       # @param query_object [GraphQL::Query] the query object for this execution
       # @return [Hash] a spec-compliant GraphQL result, as a hash
       def execute(ast_operation, root_type, query_object)
-        warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
+        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
         operation_resolution.resolve(
           query_object.irep_selection,
           root_type,

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/railtie.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
-
 module GraphQL
   class Railtie < Rails::Railtie
+    config.before_configuration do
+      # Bootsnap compile cache has similar expiration properties,
+      # so we assume that if the user has bootsnap setup it's ok
+      # to piggy back on it.
+      if ::Object.const_defined?("Bootsnap::CompileCache::ISeq") && Bootsnap::CompileCache::ISeq.cache_dir
+        Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
+      end
+    end
+
     rake_tasks do
       # Defer this so that you only need the `parser` gem when you _run_ the upgrader
       def load_upgraders

data/lib/graphql/relay/base_connection.rb

@@ -59,11 +59,11 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
-        warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+        GraphQL::Deprecation.warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
 
         deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
         if deprecated_caller
-          warn "  -> called from #{deprecated_caller}"
+          GraphQL::Deprecation.warn "  -> called from #{deprecated_caller}"
         end
 
         @context = context