graphql 1.11.4 → 1.11.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5bf42de25927dab863bd600879d33d204c54bdf124b2b4cc5b27c4c16d4f28b
-  data.tar.gz: 58b21a4dd5ba80ec0f6c3362013a6adb07c2f1af243e5a851d4c3f08554fe09d
+  metadata.gz: 4b72615f5488c1aa58c921128dd067d9f098b4617c954ac267e37efa72a9107c
+  data.tar.gz: 4690738202ecd5d048802c80f1fc87095e0c1de4a02adcba26e88415f401908c
 SHA512:
-  metadata.gz: f199d24a190910e44b189340b6a3d2a3c121ab56ba10ec6cf44d8801107db8d73541f24788b00b13ee7dd357f7bfe6ecff7001f053fe417c777bca59db5851db
-  data.tar.gz: fd0955c7f67b20370ea376d6a286fdf0ac7272ac5b243d6c309d2159a780cd0b8f92fd0e06ca312a69a16b7c8ad0ebd7bb4587feac9dc77b27da507c9a44cd8f
+  metadata.gz: 744ca52fc03919a071013a27139112c2c18e487f333ee335ea374feaef06bb904079d4c54e0ddf088d2b5dfa345172efb3063faefa792c1c8ade38616752fa1a
+  data.tar.gz: 90fffd6928d128f2516e4f49c9d729a26a57101683e19d0a90818c45f431bae221e4b8b1bf8d7bc374e20c8e98e3f0a0963877e818ae946f999d40942182cddd

data/lib/generators/graphql/object_generator.rb

@@ -40,6 +40,8 @@ module Graphql
         case type_expression
         when "Text"
           ["String", null]
+        when "Decimal"
+          ["Float", null]
         when "DateTime", "Datetime"
           ["GraphQL::Types::ISO8601DateTime", null]
         when "Date"

data/lib/generators/graphql/templates/union.erb

@@ -1,7 +1,7 @@
 <% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseUnion
-<% if possible_types.any? %>    possible_types [<%= normalized_possible_types.join(", ") %>]
+<% if possible_types.any? %>    possible_types <%= normalized_possible_types.join(", ") %>
 <% end %>  end
 end
 <% end -%>

data/lib/graphql.rb

@@ -21,6 +21,14 @@ module GraphQL
   class RequiredImplementationMissingError < Error
   end
 
+  class << self
+    def default_parser
+      @default_parser ||= GraphQL::Language::Parser
+    end
+
+    attr_writer :default_parser
+  end
+
   # Turn a query string or schema definition into an AST
   # @param graphql_string [String] a GraphQL query string or schema definition
   # @return [GraphQL::Language::Nodes::Document]
@@ -61,6 +69,14 @@ module GraphQL
       end
     end
   end
+
+  module StringMatchBackport
+    refine String do
+      def match?(pattern)
+        self =~ pattern
+      end
+    end
+  end
 end
 
 # Order matters for these:
@@ -113,6 +129,7 @@ require "graphql/introspection"
 require "graphql/analysis_error"
 require "graphql/coercion_error"
 require "graphql/invalid_name_error"
+require "graphql/integer_decoding_error"
 require "graphql/integer_encoding_error"
 require "graphql/string_encoding_error"
 require "graphql/internal_representation"

data/lib/graphql/argument.rb

@@ -3,14 +3,14 @@ module GraphQL
   # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access
+    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
     attr_reader :default_value
-    attr_accessor :description, :name, :as
+    attr_accessor :description, :name, :as, :deprecation_reason
     attr_accessor :ast_node
     attr_accessor :method_access
     alias :graphql_name :name
 
-    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access)
+    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access, :deprecation_reason)
 
     # @api private
     module DefaultPrepare

data/lib/graphql/backtrace/tracer.rb

@@ -15,7 +15,8 @@ module GraphQL
         when "validate", "analyze_query", "execute_query", "execute_query_lazy"
           metadata[:query] || metadata[:queries]
         when "execute_field", "execute_field_lazy"
-          metadata[:context]
+          # The interpreter passes `query:`, legacy passes `context:`
+          metadata[:context] || ((q = metadata[:query]) && q.context)
         else
           # Custom key, no backtrace data for this
           nil

data/lib/graphql/define/assign_global_id_field.rb

@@ -2,9 +2,9 @@
 module GraphQL
   module Define
     module AssignGlobalIdField
-      def self.call(type_defn, field_name)
+      def self.call(type_defn, field_name, **field_kwargs)
         resolve = GraphQL::Relay::GlobalIdResolve.new(type: type_defn)
-        GraphQL::Define::AssignObjectField.call(type_defn, field_name, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
+        GraphQL::Define::AssignObjectField.call(type_defn, field_name, **field_kwargs, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
       end
     end
   end

data/lib/graphql/execution/interpreter.rb

@@ -93,6 +93,16 @@ module GraphQL
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
           Interpreter::Resolve.resolve_all(final_values)
         end
+        queries.each do |query|
+          runtime = query.context.namespace(:interpreter)[:runtime]
+          if runtime
+            runtime.delete_interpreter_context(:current_path)
+            runtime.delete_interpreter_context(:current_field)
+            runtime.delete_interpreter_context(:current_object)
+            runtime.delete_interpreter_context(:current_arguments)
+          end
+        end
+        nil
       end
 
       class ListResultFailedError < GraphQL::Error

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

@@ -14,18 +14,33 @@ module GraphQL
         # This hash is the one used at runtime.
         #
         # @return [Hash<Symbol, Object>]
-        attr_reader :keyword_arguments
+        def keyword_arguments
+          @keyword_arguments ||= begin
+            kwargs = {}
+            argument_values.each do |name, arg_val|
+              kwargs[name] = arg_val.value
+            end
+            kwargs
+          end
+        end
 
-        def initialize(keyword_arguments:, argument_values:)
-          @keyword_arguments = keyword_arguments
+        # @param argument_values [nil, Hash{Symbol => ArgumentValue}]
+        def initialize(argument_values:)
           @argument_values = argument_values
+          @empty = argument_values.nil? || argument_values.empty?
         end
 
         # @return [Hash{Symbol => ArgumentValue}]
-        attr_reader :argument_values
+        def argument_values
+          @argument_values ||= {}
+        end
+
+        def empty?
+          @empty
+        end
 
-        def_delegators :@keyword_arguments, :key?, :[], :keys, :each, :values
-        def_delegators :@argument_values, :each_value
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
+        def_delegators :argument_values, :each_value
 
         def inspect
           "#<#{self.class} @keyword_arguments=#{keyword_arguments.inspect}>"

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

@@ -29,11 +29,16 @@ module GraphQL
 
         private
 
+        NO_ARGUMENTS = {}.freeze
+
         NO_VALUE_GIVEN = Object.new
 
         def prepare_args_hash(ast_arg_or_hash_or_value)
           case ast_arg_or_hash_or_value
           when Hash
+            if ast_arg_or_hash_or_value.empty?
+              return NO_ARGUMENTS
+            end
             args_hash = {}
             ast_arg_or_hash_or_value.each do |k, v|
               args_hash[k] = prepare_args_hash(v)
@@ -42,6 +47,9 @@ module GraphQL
           when Array
             ast_arg_or_hash_or_value.map { |v| prepare_args_hash(v) }
           when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
+            if ast_arg_or_hash_or_value.arguments.empty?
+              return NO_ARGUMENTS
+            end
             args_hash = {}
             ast_arg_or_hash_or_value.arguments.each do |arg|
               v = prepare_args_hash(arg.value)

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

@@ -43,23 +43,24 @@ module GraphQL
         # might be stored up in lazies.
         # @return [void]
         def run_eager
-
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
           path = []
-          @interpreter_context[:current_object] = query.root_value
-          @interpreter_context[:current_path] = path
+          set_all_interpreter_context(query.root_value, nil, nil, path)
           object_proxy = authorized_new(root_type, query.root_value, context, path)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
             # Root .authorized? returned false.
             write_in_response(path, nil)
-            nil
           else
             evaluate_selections(path, context.scoped_context, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
-            nil
           end
+          delete_interpreter_context(:current_path)
+          delete_interpreter_context(:current_field)
+          delete_interpreter_context(:current_object)
+          delete_interpreter_context(:current_arguments)
+          nil
         end
 
         def gather_selections(owner_object, owner_type, selections, selections_by_name)
@@ -116,9 +117,10 @@ module GraphQL
           end
         end
 
+        NO_ARGS = {}.freeze
+
         def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
-          @interpreter_context[:current_object] = owner_object
-          @interpreter_context[:current_path] = path
+          set_all_interpreter_context(owner_object, nil, nil, path)
           selections_by_name = {}
           gather_selections(owner_object, owner_type, selections, selections_by_name)
           selections_by_name.each do |result_name, field_ast_nodes_or_ast_node|
@@ -157,8 +159,7 @@ module GraphQL
             # to propagate `null`
             set_type_at_path(next_path, return_type)
             # Set this before calling `run_with_directives`, so that the directive can have the latest path
-            @interpreter_context[:current_path] = next_path
-            @interpreter_context[:current_field] = field_defn
+            set_all_interpreter_context(nil, field_defn, nil, next_path)
 
             context.scoped_context = scoped_context
             object = owner_object
@@ -169,44 +170,50 @@ module GraphQL
 
             begin
               kwarg_arguments = arguments(object, field_defn, ast_node)
-            rescue GraphQL::ExecutionError => e
+            rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => e
               continue_value(next_path, e, owner_type, field_defn, return_type.non_null?, ast_node)
               next
             end
 
             after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
-              if resolved_arguments.is_a? GraphQL::ExecutionError
+              case resolved_arguments
+              when GraphQL::ExecutionError, GraphQL::UnauthorizedError
                 continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node)
                 next
               end
 
-              kwarg_arguments = resolved_arguments.keyword_arguments
-
-              field_defn.extras.each do |extra|
-                case extra
-                when :ast_node
-                  kwarg_arguments[:ast_node] = ast_node
-                when :execution_errors
-                  kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
-                when :path
-                  kwarg_arguments[:path] = next_path
-                when :lookahead
-                  if !field_ast_nodes
-                    field_ast_nodes = [ast_node]
+              if resolved_arguments.empty? && field_defn.extras.empty?
+                # We can avoid allocating the `{ Symbol => Object }` hash in this case
+                kwarg_arguments = NO_ARGS
+              else
+                kwarg_arguments = resolved_arguments.keyword_arguments
+
+                field_defn.extras.each do |extra|
+                  case extra
+                  when :ast_node
+                    kwarg_arguments[:ast_node] = ast_node
+                  when :execution_errors
+                    kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
+                  when :path
+                    kwarg_arguments[:path] = next_path
+                  when :lookahead
+                    if !field_ast_nodes
+                      field_ast_nodes = [ast_node]
+                    end
+                    kwarg_arguments[:lookahead] = Execution::Lookahead.new(
+                      query: query,
+                      ast_nodes: field_ast_nodes,
+                      field: field_defn,
+                    )
+                  when :argument_details
+                    kwarg_arguments[:argument_details] = resolved_arguments
+                  else
+                    kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                   end
-                  kwarg_arguments[:lookahead] = Execution::Lookahead.new(
-                    query: query,
-                    ast_nodes: field_ast_nodes,
-                    field: field_defn,
-                  )
-                when :argument_details
-                  kwarg_arguments[:argument_details] = resolved_arguments
-                else
-                  kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                 end
               end
 
-              @interpreter_context[:current_arguments] = kwarg_arguments
+              set_all_interpreter_context(nil, nil, kwarg_arguments, nil)
 
               # Optimize for the case that field is selected only once
               if field_ast_nodes.nil? || field_ast_nodes.size == 1
@@ -412,6 +419,21 @@ module GraphQL
           true
         end
 
+        def set_all_interpreter_context(object, field, arguments, path)
+          if object
+            @context[:current_object] = @interpreter_context[:current_object] = object
+          end
+          if field
+            @context[:current_field] = @interpreter_context[:current_field] = field
+          end
+          if arguments
+            @context[:current_arguments] = @interpreter_context[:current_arguments] = arguments
+          end
+          if path
+            @context[:current_path] = @interpreter_context[:current_path] = path
+          end
+        end
+
         # @param obj [Object] Some user-returned value that may want to be batched
         # @param path [Array<String>]
         # @param field [GraphQL::Schema::Field]
@@ -419,16 +441,10 @@ module GraphQL
         # @param trace [Boolean] If `false`, don't wrap this with field tracing
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false, trace: true, &block)
-          @interpreter_context[:current_object] = owner_object
-          @interpreter_context[:current_arguments] = arguments
-          @interpreter_context[:current_path] = path
-          @interpreter_context[:current_field] = field
+          set_all_interpreter_context(owner_object, field, arguments, path)
           if schema.lazy?(lazy_obj)
             lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
-              @interpreter_context[:current_path] = path
-              @interpreter_context[:current_field] = field
-              @interpreter_context[:current_object] = owner_object
-              @interpreter_context[:current_arguments] = arguments
+              set_all_interpreter_context(owner_object, field, arguments, path)
               context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
@@ -539,6 +555,18 @@ module GraphQL
           res && res[:__dead]
         end
 
+        # Set this pair in the Query context, but also in the interpeter namespace,
+        # for compatibility.
+        def set_interpreter_context(key, value)
+          @interpreter_context[key] = value
+          @context[key] = value
+        end
+
+        def delete_interpreter_context(key)
+          @interpreter_context.delete(key)
+          @context.delete(key)
+        end
+
         def resolve_type(type, value, path)
           trace_payload = { context: context, type: type, object: value, path: path }
           resolved_type, resolved_value = query.trace("resolve_type", trace_payload) do

data/lib/graphql/integer_decoding_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Int` is given an input value outside of 32-bit integer range.
+  #
+  # For really big integer values, consider `GraphQL::Types::BigInt`
+  #
+  # @see GraphQL::Types::Int which raises this error
+  class IntegerDecodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be decoded
+    attr_reader :integer_value
+
+    def initialize(value)
+      @integer_value = value
+      super("Integer out of bounds: #{value}. \nConsider using GraphQL::Types::BigInt instead.")
+    end
+  end
+end

data/lib/graphql/introspection.rb

@@ -1,6 +1,102 @@
 # frozen_string_literal: true
 module GraphQL
   module Introspection
+    def self.query(include_deprecated_args: false)
+      # The introspection query to end all introspection queries, copied from
+      # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
+      <<-QUERY
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      ...FullType
+    }
+    directives {
+      name
+      description
+      locations
+      args {
+        ...InputValue
+      }
+    }
+  }
+}
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+      ...InputValue
+    }
+    type {
+      ...TypeRef
+    }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+    ...InputValue
+  }
+  interfaces {
+    ...TypeRef
+  }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes {
+    ...TypeRef
+  }
+}
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+  #{include_deprecated_args ? 'isDeprecated' : ''}
+  #{include_deprecated_args ? 'deprecationReason' : ''}
+}
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+      QUERY
+    end
   end
 end