graphql 1.12.5 → 1.12.10

data/lib/graphql/introspection/directive_type.rb

@@ -12,13 +12,17 @@ module GraphQL
       field :name, String, null: false, method: :graphql_name
       field :description, String, null: true
       field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
       field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
       field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
 
-      def args
-        @context.warden.arguments(@object)
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   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/pagination/active_record_relation_connection.rb

@@ -5,6 +5,13 @@ module GraphQL
   module Pagination
     # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
     class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
+      def relation_larger_than(relation, size)
+        initial_offset = relation.offset_value || 0
+        relation.offset(initial_offset + size).exists?
+      end
+
       def relation_count(relation)
         int_or_hash = if relation.respond_to?(:unscope)
           relation.unscope(:order).count(:all)

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.

data/lib/graphql/pagination/connections.rb

@@ -79,11 +79,12 @@ module GraphQL
           context: context,
           parent: parent,
           field: field,
-          max_page_size: field.max_page_size || context.schema.default_max_page_size,
+          max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
           first: arguments[:first],
           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_larger_than(sliced_nodes, first)
+            end
           else
             false
           end
@@ -49,6 +53,13 @@ module GraphQL
 
       private
 
+      # @param relation [Object] A database query object
+      # @param size [Integer] The value against which we check the relation size
+      # @return [Boolean] True if the number of items in this relation is larger than `size`
+      def relation_larger_than(relation, size)
+        relation_count(set_limit(relation, size + 1)) == size + 1
+      end
+
       # @param relation [Object] A database query object
       # @return [Integer, nil] The offset value, or nil if there isn't one
       def relation_offset(relation)

data/lib/graphql/query.rb

@@ -195,9 +195,7 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self], context: @context)
-        }
+        Execution::Multiplex.run_queries(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end

data/lib/graphql/query/null_context.rb

@@ -9,10 +9,16 @@ module GraphQL
         def visible_type?(t); true; end
       end
 
+      class NullQuery
+        def with_error_handling
+          yield
+        end
+      end
+
       attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
-        @query = nil
+        @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = GraphQL::Schema.new
         @warden = NullWarden.new(

data/lib/graphql/query/validation_pipeline.rb

@@ -36,7 +36,7 @@ module GraphQL
         @valid
       end
 
-      # @return [Array<GraphQL::StaticValidation::Error >] Static validation errors for the query string
+      # @return [Array<GraphQL::StaticValidation::Error, GraphQL::Query::VariableValidationError>] Static validation errors for the query string
       def validation_errors
         ensure_has_validated
         @validation_errors

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

@@ -98,6 +98,9 @@ module GraphQL
       result = schema.public_send(method_name, only: @only, except: @except, context: context)
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
+      if !result.end_with?("\n")
+        result += "\n"
+      end
       File.write(file, result)
     end
 

data/lib/graphql/schema.rb

@@ -355,23 +355,6 @@ module GraphQL
     # For forwards-compatibility with Schema classes
     alias :graphql_definition :itself
 
-    # Validate a query string according to this schema.
-    # @param string_or_document [String, GraphQL::Language::Nodes::Document]
-    # @return [Array<GraphQL::StaticValidation::Error >]
-    def validate(string_or_document, rules: nil, context: nil)
-      doc = if string_or_document.is_a?(String)
-        GraphQL.parse(string_or_document)
-      else
-        string_or_document
-      end
-      query = GraphQL::Query.new(self, document: doc, context: context)
-      validator_opts = { schema: self }
-      rules && (validator_opts[:rules] = rules)
-      validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query, timeout: validate_timeout)
-      res[:errors]
-    end
-
     def deprecated_define(**kwargs, &block)
       super
       ensure_defined
@@ -711,7 +694,8 @@ module GraphQL
     alias :_schema_class :class
     def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
-    def_delegators :_schema_class, :error_handler, :rescues
+    def_delegators :_schema_class, :error_handler
+    def_delegators :_schema_class, :validate
 
 
     # Given this schema member, find the class-based definition object
@@ -861,7 +845,6 @@ module GraphQL
       def_delegators :graphql_definition,
         # Execution
         :execution_strategy_for_operation,
-        :validate,
         # Configuration
         :metadata, :redefine,
         :id_from_object_proc, :object_from_id_proc,
@@ -989,7 +972,7 @@ module GraphQL
           schema_defn.lazy_methods.set(lazy_class, value_method)
         end
 
-        rescues.each do |err_class, handler|
+        error_handler.each_rescue do |err_class, handler|
           schema_defn.rescue_from(err_class, &handler)
         end
 
@@ -1293,6 +1276,23 @@ module GraphQL
         end
       end
 
+      # Validate a query string according to this schema.
+      # @param string_or_document [String, GraphQL::Language::Nodes::Document]
+      # @return [Array<GraphQL::StaticValidation::Error >]
+      def validate(string_or_document, rules: nil, context: nil)
+        doc = if string_or_document.is_a?(String)
+          GraphQL.parse(string_or_document)
+        else
+          string_or_document
+        end
+        query = GraphQL::Query.new(self, document: doc, context: context)
+        validator_opts = { schema: self }
+        rules && (validator_opts[:rules] = rules)
+        validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
+        res = validator.validate(query, timeout: validate_timeout)
+        res[:errors]
+      end
+
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)
@@ -1424,7 +1424,7 @@ module GraphQL
 
       def rescue_from(*err_classes, &handler_block)
         err_classes.each do |err_class|
-          own_rescues[err_class] = handler_block
+          error_handler.rescue_from(err_class, handler_block)
         end
       end
 
@@ -1468,10 +1468,6 @@ module GraphQL
         super
       end
 
-      def rescues
-        find_inherited_value(:rescues, EMPTY_HASH).merge(own_rescues)
-      end
-
       def object_from_id(node_id, ctx)
         raise GraphQL::RequiredImplementationMissingError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
       end
@@ -1548,15 +1544,10 @@ module GraphQL
       def parse_error(parse_err, ctx)
         ctx.errors.push(parse_err)
       end
-      attr_writer :error_handler
 
-      # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
+      # @return [GraphQL::Execution::Errors]
       def error_handler
-        if defined?(@error_handler)
-          @error_handler
-        else
-          find_inherited_value(:error_handler, GraphQL::Execution::Errors::NullErrorHandler)
-        end
+        @error_handler ||= GraphQL::Execution::Errors.new(self)
       end
 
       def lazy_resolve(lazy_class, value_method)
@@ -1744,10 +1735,6 @@ module GraphQL
         @own_plugins ||= []
       end
 
-      def own_rescues
-        @own_rescues ||= {}
-      end
-
       def own_orphan_types
         @own_orphan_types ||= []
       end
@@ -1990,7 +1977,6 @@ module GraphQL
     end
 
     # Install these here so that subclasses will also install it.
-    use(GraphQL::Execution::Errors)
     use(GraphQL::Pagination::Connections)
 
     protected

data/lib/graphql/schema/argument.rb

@@ -266,7 +266,9 @@ module GraphQL
               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)
+              context.query.with_error_handling do
+                owner.load_application_object(self, loads, coerced_value, context)
+              end
             end
           end
 

data/lib/graphql/schema/field/connection_extension.rb

@@ -42,6 +42,7 @@ module GraphQL
               value.after_value ||= original_arguments[:after]
               value.last_value ||= original_arguments[:last]
               value.before_value ||= original_arguments[:before]
+              value.arguments ||= original_arguments
               value.field ||= field
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size

data/lib/graphql/schema/input_object.rb

@@ -226,8 +226,8 @@ module GraphQL
         # It's funny to think of a _result_ of an input object.
         # This is used for rendering the default value in introspection responses.
         def coerce_result(value, ctx)
-          # Allow the application to provide values as :symbols, and convert them to the strings
-          value = value.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
+          # Allow the application to provide values as :snake_symbols, and convert them to the camelStrings
+          value = value.reduce({}) { |memo, (k, v)| memo[Member::BuildType.camelize(k.to_s)] = v; memo }
 
           result = {}