graphql 2.6.14 → 2.6.15

data/lib/graphql/execution/variable_values.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+# typed: true
+module GraphQL
+  module Execution
+    # Validates and coerces a query's provided variables in a single pass.
+    #
+    # Reading methods (`#[]`, `#fetch`, `#to_h`, ...) return the values _as provided_ by the client
+    # (or the default value from the query string), so that existing callers keep working.
+    # Coerced values are available from `#coerced_value` for the runtime.
+    class VariableValues
+      extend Forwardable
+
+      # **Returns**
+      #
+      # - `Array<GraphQL::Query::VariableValidationError>` — Any errors encountered when coercing the provided variables
+      attr_reader :errors
+
+      attr_reader :context
+
+      def initialize(query, ast_variables, provided_variables)
+        @query = query
+        @context = query.context
+        @types = query.types
+        @schema = query.schema
+        @provided_variables = deep_stringify(provided_variables)
+        @errors = []
+        @storage = {}
+        @coerced_values = {}
+        build_values(ast_variables)
+      end
+
+      def_delegators :@storage, :length, :key?, :[], :fetch, :to_h, :each
+
+      # **Returns**
+      #
+      # - `Object` — The coerced value for the variable named `name`, or `nil` if it wasn't given
+      def coerced_value(name) # :nodoc:
+        @coerced_values[name]
+      end
+
+      private
+
+      UNEXPECTED_NULL_MESSAGE = "Expected value to not be null"
+      INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object."
+
+      def build_values(ast_variables)
+        max_errors = @schema.validate_max_errors
+        ast_variables.each do |ast_variable|
+          if max_errors && max_errors <= @errors.size
+            add_max_errors_reached_message
+            break
+          end
+          variable_type = GraphQL::Schema::TypeExpression.build_type(@types, ast_variable.type)
+          if variable_type.nil? || !variable_type.unwrap.kind.input?
+            # Pass -- it will get handled by a validator
+            next
+          end
+
+          variable_name = ast_variable.name
+          default_value = ast_variable.default_value
+          value_was_provided = @provided_variables.key?(variable_name)
+
+          if value_was_provided || default_value.nil?
+            provided_value = @provided_variables[variable_name]
+            validation_result = GraphQL::Query::InputValidationResult.new
+            remaining_errors = max_errors ? max_errors - @errors.size : nil
+            path = []
+            coerced_value = begin
+              coerce_variable_value(provided_value, variable_type, path, validation_result, remaining_errors)
+            rescue GraphQL::ExecutionError => ex
+              # TODO: This should really include the path to the problematic node in the variable value
+              validation_result = GraphQL::Query::InputValidationResult.from_problem(ex.message)
+              nil
+            end
+            if !validation_result.valid?
+              @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
+            elsif value_was_provided
+              @storage[variable_name] = provided_value
+              @coerced_values[variable_name] = coerced_value
+            end
+          elsif default_value.is_a?(Language::Nodes::NullValue)
+            @storage[variable_name] = nil
+            @coerced_values[variable_name] = nil
+          else
+            @storage[variable_name] = default_value
+            @coerced_values[variable_name] = @query.input_values.value_from_ast(default_value, variable_type)
+          end
+        end
+      end
+
+      def coerce_variable_value(value, type, path, result, max_errors)
+        if type.non_null?
+          if value.nil?
+            result.add_problem(UNEXPECTED_NULL_MESSAGE, path.dup)
+            return nil
+          end
+          type = type.of_type
+        end
+
+        if value.nil?
+          nil
+        elsif type.list?
+          coerce_list_value(value, type.of_type, path, result, max_errors)
+        elsif type.kind.input_object?
+          coerce_input_object_value(value, type, path, result)
+        elsif type.kind.enum?
+          coerce_enum_value(value, type, path, result)
+        elsif type.kind.scalar?
+          coerce_scalar_value(value, type, path, result)
+        else
+          raise GraphQL::Error, "Unexpected input type: #{type.graphql_name}."
+        end
+      end
+
+      def coerce_list_value(value, item_type, path, result, max_errors)
+        items = value.is_a?(Array) ? value : [value]
+        coerced_items = Array.new(items.size)
+        invalid_items = 0
+        items.each_with_index do |item, idx|
+          item_result = GraphQL::Query::InputValidationResult.new
+          path.push(idx)
+          coerced_items[idx] = coerce_variable_value(item, item_type, path, item_result, nil)
+          path.pop
+          if !item_result.valid?
+            if max_errors
+              if invalid_items == max_errors
+                result.add_problem("Too many errors processing list variable, max validation error limit reached. Execution aborted", [*path, nil])
+                break
+              end
+              invalid_items += 1
+            end
+            item_result.problems.each do |problem|
+              result.add_problem(problem["explanation"], problem["path"], message: problem["message"], extensions: problem["extensions"])
+            end
+          end
+        end
+        coerced_items.freeze
+      end
+
+      def coerce_input_object_value(value, type, path, result)
+        if value.is_a?(Array) || !(value.respond_to?(:to_h) || value.respond_to?(:to_unsafe_h))
+          result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(value) }, path.dup)
+          return nil
+        end
+
+        coerced_obj = {}
+        value.each do |argument_name, argument_value|
+          path.push(argument_name)
+          argument = @types.argument(type, argument_name)
+          if argument.nil?
+            result.add_problem("Field is not defined on #{type.graphql_name}", path.dup)
+          else
+            if argument_value.nil? && argument.replace_null_with_default?
+              coerced_obj[argument.keyword] = argument.default_value
+            else
+              coerced_obj[argument.keyword] = coerce_variable_value(argument_value, argument.type, path, result, nil)
+            end
+          end
+          path.pop
+        end
+
+        @types.arguments(type).each do |argument|
+          if !value.key?(argument.graphql_name)
+            if argument.default_value?
+              coerced_obj[argument.keyword] = argument.default_value
+            elsif argument.type.non_null?
+              path.push(argument.graphql_name)
+              result.add_problem(UNEXPECTED_NULL_MESSAGE, path.dup)
+              path.pop
+            end
+          end
+        end
+
+        if type.one_of?
+          if value.size == 1
+            value.each do |name, v|
+              if v.nil?
+                result.add_problem("'#{type.graphql_name}' requires exactly one argument, but '#{name}' was `null`.", path.dup)
+              end
+            end
+          else
+            result.add_problem("'#{type.graphql_name}' requires exactly one argument, but #{value.size} were provided.", path.dup)
+          end
+        end
+
+        coerced_obj
+      end
+
+      def coerce_enum_value(value, type, path, result)
+        allowed_values = @types.enum_values(type)
+        matching_value = allowed_values.find { |v| v.graphql_name == value }
+        if matching_value.nil?
+          result.add_problem("Expected #{GraphQL::Language.serialize(value)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}", path.dup)
+          nil
+        else
+          begin
+            type.coerce_input(value, @context)
+          rescue GraphQL::UnauthorizedEnumValueError => enum_err
+            @schema.unauthorized_object(enum_err)
+          end
+        end
+      rescue GraphQL::ExecutionError => err
+        result.add_problem(err.message, path.dup)
+        nil
+      end
+
+      def coerce_scalar_value(value, type, path, result)
+        coerced_value = begin
+          type.coerce_input(value, @context)
+        rescue GraphQL::CoercionError => err
+          result.add_problem(err.message, path.dup, message: err.message, extensions: err.extensions)
+          return nil
+        rescue GraphQL::ExecutionError => err
+          result.add_problem(err.message, path.dup)
+          return nil
+        rescue StandardError => err
+          @query.handle_or_reraise(err)
+        end
+
+        if coerced_value.nil?
+          result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{type.graphql_name}", path.dup)
+        end
+        coerced_value
+      end
+
+      def add_max_errors_reached_message
+        message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
+        validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
+        @errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message)
+      end
+
+      def deep_stringify(val)
+        case val
+        when Array
+          val.map { |v| deep_stringify(v) }
+        when Hash
+          new_val = {}
+          val.each do |k, v|
+            new_val[k.to_s] = deep_stringify(v)
+          end
+          new_val
+        else
+          val
+        end
+      end
+    end
+  end
+end

data/lib/graphql/float_decoding_error.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   # This error is raised when `Types::Float` is given a non-finite input value.
   class FloatDecodingError < GraphQL::RuntimeTypeError
     # The value which couldn't be decoded
+    #: Float
     attr_reader :float_value
 
+    #: (Float value) -> void
     def initialize(value)
       @float_value = value
       super("Float is not finite: #{value.inspect}.")

data/lib/graphql/integer_decoding_error.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   # This error is raised when `Types::Int` is given an input value outside of 32-bit integer range.
   #
@@ -8,8 +8,10 @@ module GraphQL
   # See [GraphQL::Types::Int](rdoc-ref:GraphQL::Types::Int) which raises this error
   class IntegerDecodingError < GraphQL::RuntimeTypeError
     # The value which couldn't be decoded
+    #: Integer
     attr_reader :integer_value
 
+    #: (Integer value) -> void
     def initialize(value)
       @integer_value = value
       super("Integer out of bounds: #{value}. \nConsider using GraphQL::Types::BigInt instead.")

data/lib/graphql/introspection/base_object.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
     class BaseObject < GraphQL::Schema::Object

data/lib/graphql/introspection/directive_location_enum.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
     class DirectiveLocationEnum < GraphQL::Schema::Enum

data/lib/graphql/introspection/directive_type.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
     class DirectiveType < Introspection::BaseObject
@@ -22,12 +22,14 @@ module GraphQL
 
       field :is_repeatable, Boolean, method: :repeatable?
 
+      #: (singleton(GraphQL::Schema::Directive) object, GraphQL::Query::Context context, include_deprecated: bool) -> Array[GraphQL::Schema::Argument]
       def self.resolve_args(object, context, include_deprecated:)
         args = context.types.arguments(object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end
 
+      #: (include_deprecated: bool) -> Array[GraphQL::Schema::Argument]
       def args(include_deprecated:)
         self.class.resolve_args(object, context, include_deprecated: include_deprecated)
       end

data/lib/graphql/introspection/dynamic_fields.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
     class DynamicFields < Introspection::BaseObject
       field :__typename, String, "The name of this type", null: false, dynamic_introspection: true, resolve_each: true
 
+      #: -> ::String
       def __typename
         self.class.__typename(object, context)
       end
 
+      #: (untyped object, GraphQL::Query::Context context) -> ::String
       def self.__typename(object, context)
         object.class.graphql_name
       end

data/lib/graphql/introspection/enum_value_type.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
     class EnumValueType < Introspection::BaseObject
@@ -12,10 +12,12 @@ module GraphQL
       field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
+      #: (GraphQL::Schema::EnumValue object, GraphQL::Query::Context context) -> bool
       def self.resolve_is_deprecated(object, context)
         !!object.deprecation_reason
       end
 
+      #: -> bool
       def is_deprecated
         self.class.resolve_is_deprecated(object, context)
       end

data/lib/graphql/introspection/field_type.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
     class FieldType < Introspection::BaseObject
@@ -15,20 +15,24 @@ module GraphQL
       field :is_deprecated, Boolean, null: false, resolve_each: :resolve_is_deprecated
       field :deprecation_reason, String
 
+      #: (GraphQL::Schema::Field object, GraphQL::Query::Context _context) -> bool
       def self.resolve_is_deprecated(object, _context)
         !!object.deprecation_reason
       end
 
+      #: -> bool
       def is_deprecated
         self.class.resolve_is_deprecated(object, context)
       end
 
+      #: (GraphQL::Schema::Field object, GraphQL::Query::Context context, include_deprecated: bool) -> Array[GraphQL::Schema::Argument]
       def self.resolve_args(object, context, include_deprecated:)
         args = context.types.arguments(object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end
 
+      #: (include_deprecated: bool) -> Array[GraphQL::Schema::Argument]
       def args(include_deprecated:)
         self.class.resolve_args(object, context, include_deprecated: include_deprecated)
       end

data/lib/graphql/introspection/type_kind_enum.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
     class TypeKindEnum < GraphQL::Schema::Enum

data/lib/graphql/introspection.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Introspection
+    #: (?include_deprecated_args: bool, ?include_schema_description: bool, ?include_is_repeatable: bool, ?include_specified_by_url: bool, ?include_is_one_of: bool) -> String
     def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
       # The introspection query to end all introspection queries, copied from
       # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js

data/lib/graphql/language/comment.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Language
     module Comment
+      #: (String str, ?indent: String) -> String
       def self.print(str, indent: '')
         lines = str.split("\n").map do |line|
           comment_str = "".dup

data/lib/graphql/language/generation.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   module Language
     # Exposes [.generate](rdoc-ref:.generate), which turns AST nodes back into query strings.
@@ -30,6 +30,7 @@ module GraphQL
       #
       # :call-seq:
       #   generate(GraphQL::Language::Nodes::AbstractNode node, String indent:, GraphQL::Language::Printer printer:) -> String
+      #: (GraphQL::Language::Nodes::AbstractNode node, ?indent: String, ?printer: GraphQL::Language::Printer) -> String
       def generate(node, indent: "", printer: GraphQL::Language::Printer.new)
         printer.print(node, indent: indent)
       end

data/lib/graphql/language/lexer.rb

@@ -32,17 +32,16 @@ module GraphQL
       attr_reader :pos, :tokens_count
 
       def advance
-        loop do
-          @scanner.skip(IGNORE_REGEXP)
-          if @scanner.skip(COMMENT_REGEXP)
-            @tokens_count += 1
-            if @tokens_count > @max_tokens
-              @pos = @scanner.pos
-              raise_parse_error("This query is too large to execute.")
-            end
-            next
+        @scanner.skip(IGNORE_REGEXP)
+        # A failed skip clears matched_size, which debug_token_value relies on for UNKNOWN_CHAR.
+        while @scanner.skip("#")
+          @scanner.skip(COMMENT_BODY_REGEXP)
+          @tokens_count += 1
+          if @tokens_count > @max_tokens
+            @pos = @scanner.pos
+            raise_parse_error("This query is too large to execute.")
           end
-          break
+          @scanner.skip(IGNORE_REGEXP)
         end
 
         if @scanner.eos?
@@ -50,10 +49,10 @@ module GraphQL
           return false
         end
         @tokens_count += 1
+        @pos = @scanner.pos
         if @tokens_count > @max_tokens
           raise_parse_error("This query is too large to execute.")
         end
-        @pos = @scanner.pos
         next_byte = @string.getbyte(@pos)
         next_byte_is_for = FIRST_BYTES[next_byte]
         case next_byte_is_for
@@ -82,11 +81,12 @@ module GraphQL
           @scanner.skip(IDENTIFIER_REGEXP)
           :IDENTIFIER
         when ByteFor::NUMBER
-          if len = @scanner.skip(NUMERIC_REGEXP)
-
-            if GraphQL.reject_numbers_followed_by_names
-              new_pos = @scanner.pos
-              peek_byte = @string.getbyte(new_pos)
+          if @scanner.skip(NUMERIC_REGEXP)
+            peek_byte = @string.getbyte(@scanner.pos)
+            if peek_byte == 46 || (peek_byte && peek_byte >= 48 && peek_byte <= 57)
+              raise_parse_error("Invalid number: unexpected character #{peek_byte.chr.inspect}")
+            end
+            if peek_byte && GraphQL.reject_numbers_followed_by_names
               next_first_byte = FIRST_BYTES[peek_byte]
               if next_first_byte == ByteFor::NAME || next_first_byte == ByteFor::IDENTIFIER
                 number_part = token_value
@@ -152,7 +152,9 @@ module GraphQL
         "\\t" => "\t",
       }
       UTF_8 = /\\u(?:([\da-f]{4})|\{([\da-f]+)\})(?:\\u([\da-f]{4}))?/i
-      VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
+      # Surrogate pairs are combined by `UTF_8` during replacement; validating each escape alone keeps this unambiguous, so it can't backtrack exponentially.
+      VALID_UTF_8 = /\\u(?:[\da-f]{4}|\{[\da-f]+\})/i
+      VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{VALID_UTF_8})*\z/o
       ESCAPED = /(?:#{ESCAPES}|#{UTF_8})/o
 
       def string_value
@@ -183,13 +185,20 @@ module GraphQL
       end
 
       def line_number
-        @scanner.string.byteslice(0, @pos).b.count("\n".b) + 1
+        line_prefix = @scanner.string.byteslice(0, @pos).b
+        line_number = line_prefix.count("\r") + line_prefix.count("\n") + 1
+        offset = 0 #: Integer?
+        while (offset = line_prefix.index("\r\n", offset))
+          line_number -= 1
+          offset += 2
+        end
+        line_number
       end
 
       def column_number
         line_prefix = @scanner.string.byteslice(0, @pos)
         line_prefix = line_prefix.b unless line_prefix.valid_encoding?
-        newline_index = line_prefix.rindex("\n")
+        newline_index = line_prefix.rindex(/[\r\n]/)
         newline_index ? line_prefix.length - newline_index : line_prefix.length + 1
       end
 
@@ -198,12 +207,11 @@ module GraphQL
       end
 
       IGNORE_REGEXP = /[, \r\n\t\uFEFF]+/
-      COMMENT_REGEXP = /\#[^\n]*/
+      COMMENT_BODY_REGEXP = /[^\n\r]*/
       IDENTIFIER_REGEXP = /[_A-Za-z][_0-9A-Za-z]*/
       INT_REGEXP =        /-?(?:[0]|[1-9][0-9]*)/
       FLOAT_DECIMAL_REGEXP = /[.][0-9]+/
       FLOAT_EXP_REGEXP =     /[eE][+-]?[0-9]+/
-      # TODO: FLOAT_EXP_REGEXP should not be allowed to follow INT_REGEXP, integers are not allowed to have exponent parts.
       NUMERIC_REGEXP =  /#{INT_REGEXP}(#{FLOAT_DECIMAL_REGEXP}#{FLOAT_EXP_REGEXP}|#{FLOAT_DECIMAL_REGEXP}|#{FLOAT_EXP_REGEXP})?/
 
       KEYWORDS = [

data/lib/graphql/language/parser.rb

@@ -47,7 +47,7 @@ module GraphQL
             document
           end
         rescue SystemStackError
-          raise GraphQL::ParseError.new("This query is too large to execute.", nil, nil, @query_str, filename: @filename)
+          raise GraphQL::ParseError.new("This query is too large to execute.", nil, nil, @graphql_str, filename: @filename)
         end
       end
 
@@ -89,8 +89,10 @@ module GraphQL
           la = []
           idx = 0 #: Integer?
           while idx
-            idx = graphql_str.index("\n", idx)
+            idx = graphql_str.index(/[\r\n]/, idx)
             if idx
+              # Record the final byte so CRLF counts as one line break.
+              idx += 1 if graphql_str.getbyte(idx) == 13 && graphql_str.getbyte(idx + 1) == 10
               la << idx
               idx += 1
             end
@@ -172,7 +174,7 @@ module GraphQL
               var_type = self.type || raise_parse_error("Missing type definition for variable: $#{var_name}")
               default_value = if at?(:EQUALS)
                 advance_token
-                value
+                value(const: true)
               end
 
               directives = parse_directives #: untyped
@@ -491,7 +493,7 @@ module GraphQL
         type = self.type
         default_value = if at?(:EQUALS)
           advance_token
-          value
+          value(const: true)
         else
           nil
         end
@@ -715,7 +717,7 @@ module GraphQL
         token_value
       end
 
-      def value
+      def value(const: false)
         case token_name
         when :INT
           expect_token_value(:INT).to_i
@@ -738,7 +740,7 @@ module GraphQL
           advance_token
           list = []
           while !at?(:RBRACKET)
-            list << value
+            list << value(const: const)
           end
           expect_token(:RBRACKET)
           list
@@ -750,11 +752,12 @@ module GraphQL
             loc = pos #: untyped
             n = parse_name
             expect_token(:COLON)
-            args << Argument.new(pos: loc, name: n, value: value, filename: @filename, source: self)
+            args << Argument.new(pos: loc, name: n, value: value(const: const), filename: @filename, source: self)
           end
           expect_token(:RCURLY)
           InputObject.new(pos: start, arguments: args, filename: @filename, source: self)
         when :VAR_SIGN
+          raise_parse_error("Unexpected variable in constant value") if const
           loc = pos
           advance_token
           VariableIdentifier.new(pos: loc, name: parse_name, filename: @filename, source: self)

data/lib/graphql/language.rb

@@ -59,7 +59,7 @@ module GraphQL
         if scanner.skip('"""')
           inside_triple_quoted_string = !inside_triple_quoted_string
           new_query_str && (new_query_str << scanner.matched)
-        elsif scanner.skip(/(?:\\"|[^"\n\r])+/m)
+        elsif scanner.skip(inside_single_quoted_string ? /(?>\\[\\"]|[^"\n\r])+/ : /(?:\\"|[^"\n\r])+/m)
           new_query_str && (new_query_str << scanner.matched)
         elsif scanner.skip('"')
           new_query_str && (new_query_str << '"')

data/lib/graphql/name_validator.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 module GraphQL
   class NameValidator
     VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 
+    #: (String | Symbol name) -> void
     def self.validate!(name)
       name = name.is_a?(String) ? name : name.to_s
       raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless name.match?(VALID_NAME_REGEX)

data/lib/graphql/pagination.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 require "graphql/pagination/array_connection"
 require "graphql/pagination/active_record_relation_connection"
 require "graphql/pagination/connections"

data/lib/graphql/query/fingerprint.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 require 'digest/sha2'
 
@@ -20,6 +20,7 @@ module GraphQL
       #
       # :call-seq:
       #   generate(input_str) -> String
+      #: (String input_str) -> String
       def self.generate(input_str)
         # Implemented to be:
         # - Short (and uniform) length

data/lib/graphql/query/partial.rb

@@ -102,6 +102,10 @@ module GraphQL
         @query.variables
       end
 
+      def input_values
+        @query.input_values
+      end
+
       def fragments
         @query.fragments
       end