graphql 1.10.7 → 1.10.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dffbc22cc92ab7e74cf26f0a6e916ae1f03014722e350318af8ee367c9eb6f40
-  data.tar.gz: 8b98748a98c2a7b5d471542989245a16d148b44519c69aa51cec062649357b31
+  metadata.gz: 13caa4920df03f81232a23cf9fe5707ee3602a6c42bedace93870645f35d1248
+  data.tar.gz: 597cbe2fd51c36a0e0de158d51c70d1d057a2712d44a34c71872ef0586a9c3d9
 SHA512:
-  metadata.gz: bf169d1fe41d60ad045e0faae46cfa263d4b5f2bffd56bdd527b940702e9a6e44996d7b8402a6a213a593e68adcd1b885b3ba8d7240b236db1383ae9d9073f6c
-  data.tar.gz: 24293245691980f79e316977fe24a6dfc6025f25d7d46806d6e46a8cc44ce9d1f84a7217487fd147209d6bef4a4ffdb0d67645fb87506850e420683a745aa90a
+  metadata.gz: ca5468c4b6632a4028f4bebf226c7a3aee5bb6786096b1b5a843b2ae476043160b1fe52111ae70d62c5a35cc66f9edd2d903128ebb2412c87054b9040f2a55aa
+  data.tar.gz: e9ad2d87cb3898d849266bb743251d922024541ee9d08090cb4f7898331fa15962697a87f386011b7450ca9af3c730c23ff74ca4d2191af6c319d3168add1bdd

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -54,7 +54,7 @@ module GraphQL
             case defined_complexity
             when Proc
               arguments = @query.arguments_for(@node, @field_definition)
-              defined_complexity.call(@query.context, arguments, child_complexity)
+              defined_complexity.call(@query.context, arguments.keyword_arguments, child_complexity)
             when Numeric
               defined_complexity + child_complexity
             else

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -43,8 +43,8 @@ module GraphQL
             @storage = storage
           end
 
-          def each
-            @storage.each { |i| yield(i) }
+          def each(&block)
+            @storage.each(&block)
           end
         end
 

data/lib/graphql/execution/interpreter.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "graphql/execution/interpreter/argument_value"
+require "graphql/execution/interpreter/arguments"
 require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
 require "graphql/execution/interpreter/hash_response"

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # A container for metadata regarding arguments present in a GraphQL query.
+      # @see Interpreter::Arguments#argument_values for a hash of these objects.
+      class ArgumentValue
+        def initialize(definition:, value:, default_used:)
+          @definition = definition
+          @value = value
+          @default_used = default_used
+        end
+
+        # @return [Object] The Ruby-ready value for this Argument
+        attr_reader :value
+
+        # @return [GraphQL::Schema::Argument] The definition instance for this argument
+        attr_reader :definition
+
+        # @return [Boolean] `true` if the schema-defined `default_value:` was applied in this case. (No client-provided value was present.)
+        def default_used?
+          @default_used
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # A wrapper for argument hashes in GraphQL queries.
+      #
+      # @see GraphQL::Query#arguments_for to get access to these objects.
+      class Arguments
+        extend Forwardable
+
+        # The Ruby-style arguments hash, ready for a resolver.
+        # This hash is the one used at runtime.
+        #
+        # @return [Hash<Symbol, Object>]
+        attr_reader :keyword_arguments
+
+        def initialize(keyword_arguments:, argument_values:)
+          @keyword_arguments = keyword_arguments
+          @argument_values = argument_values
+        end
+
+        # Yields `ArgumentValue` instances which contain detailed metadata about each argument.
+        def each_value
+          argument_values.each { |arg_v| yield(arg_v) }
+        end
+
+        # @return [Hash{Symbol => ArgumentValue}]
+        attr_reader :argument_values
+
+        def_delegators :@keyword_arguments, :key?, :[], :keys, :each, :values
+
+        def inspect
+          "#<#{self.class} @keyword_arguments=#{keyword_arguments.inspect}>"
+        end
+      end
+    end
+  end
+end

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

@@ -14,13 +14,9 @@ module GraphQL
                 # Then call into the schema to coerce those incoming values
                 args = arg_owner.coerce_arguments(parent_object, args_hash, query.context)
 
-                h3[parent_object] = if args.is_a?(GraphQL::Execution::Lazy)
-                  args.then { |resolved_args|
-                    # when this promise is resolved, update the cache with the resolved value
-                    h3[parent_object] = resolved_args
-                  }
-                else
-                  args
+                h3[parent_object] = @query.schema.after_lazy(args) do |resolved_args|
+                  # when this promise is resolved, update the cache with the resolved value
+                  h3[parent_object] = resolved_args
                 end
               end
             end

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

@@ -174,7 +174,14 @@ module GraphQL
               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 |kwarg_arguments|
+            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
+                continue_value(next_path, resolved_arguments, field_defn, return_type.non_null?, ast_node)
+                next
+              end
+
+              kwarg_arguments = resolved_arguments.keyword_arguments
+
               # It might turn out that making arguments for every field is slow.
               # If we have to cache them, we'll need a more subtle approach here.
               field_defn.extras.each do |extra|
@@ -194,6 +201,8 @@ module GraphQL
                     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
@@ -369,11 +378,12 @@ module GraphQL
           end
         end
 
-        def resolve_with_directives(object, ast_node)
-          run_directive(object, ast_node, 0) { yield }
+        def resolve_with_directives(object, ast_node, &block)
+          return yield if ast_node.directives.empty?
+          run_directive(object, ast_node, 0, &block)
         end
 
-        def run_directive(object, ast_node, idx)
+        def run_directive(object, ast_node, idx, &block)
           dir_node = ast_node.directives[idx]
           if !dir_node
             yield
@@ -382,9 +392,9 @@ module GraphQL
             if !dir_defn.is_a?(Class)
               dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
-            dir_args = arguments(nil, dir_defn, dir_node)
+            dir_args = arguments(nil, dir_defn, dir_node).keyword_arguments
             dir_defn.resolve(object, dir_args, context) do
-              run_directive(object, ast_node, idx + 1) { yield }
+              run_directive(object, ast_node, idx + 1, &block)
             end
           end
         end
@@ -393,7 +403,7 @@ module GraphQL
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
             dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
-            args = arguments(graphql_object, dir_defn, dir_node)
+            args = arguments(graphql_object, dir_defn, dir_node).keyword_arguments
             if !dir_defn.include?(graphql_object, args, context)
               return false
             end
@@ -407,7 +417,7 @@ module GraphQL
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @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)
+        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
@@ -432,11 +442,9 @@ module GraphQL
                   end
                 end
                 rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
-                  yield(err)
-              end
-              after_lazy(inner_obj, owner: owner, field: field, path: path, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
-                yield(really_inner_obj)
+                  err
               end
+              after_lazy(inner_obj, owner: owner, field: field, path: path, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager, trace: trace, &block)
             end
 
             if eager

data/lib/graphql/execution/lookahead.rb

@@ -55,7 +55,9 @@ module GraphQL
           @arguments
         else
           @arguments = if @field
-            @query.arguments_for(@ast_nodes.first, @field)
+            @query.schema.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
+              args.is_a?(Execution::Interpreter::Arguments) ? args.keyword_arguments : args
+            end
           else
             nil
           end

data/lib/graphql/internal_representation/scope.rb

@@ -66,11 +66,11 @@ module GraphQL
       # Call the block for each type in `self`.
       # This uses the simplest possible expression of `self`,
       # so if this scope is defined by an abstract type, it gets yielded.
-      def each
+      def each(&block)
         if @abstract_type
           yield(@type)
         else
-          @types.each { |t| yield(t) }
+          @types.each(&block)
         end
       end
 

data/lib/graphql/internal_representation/visit.rb

@@ -23,11 +23,11 @@ module GraphQL
 
       # Traverse a node in a rewritten query tree,
       # visiting the node itself and each of its typed children.
-      def each_node(node)
+      def each_node(node, &block)
         yield(node)
         node.typed_children.each do |obj_type, children|
           children.each do |name, node|
-            each_node(node) { |n| yield(n) }
+            each_node(node, &block)
           end
         end
       end

data/lib/graphql/relay/base_connection.rb

@@ -74,8 +74,6 @@ module GraphQL
 
       def decode(data)
         @encoder.decode(data, nonce: true)
-      rescue ArgumentError
-        raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
       end
 
       # The value passed as `first:`, if there was one. Negative numbers become `0`.

data/lib/graphql/schema.rb

@@ -101,14 +101,12 @@ module GraphQL
       # - Right away, if `value` is not registered with `lazy_resolve`
       # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
       # @api private
-      def after_lazy(value)
+      def after_lazy(value, &block)
         if lazy?(value)
           GraphQL::Execution::Lazy.new do
             result = sync_lazy(value)
             # The returned result might also be lazy, so check it, too
-            after_lazy(result) do |final_result|
-              yield(final_result) if block_given?
-            end
+            after_lazy(result, &block)
           end
         else
           yield(value) if block_given?
@@ -146,10 +144,10 @@ module GraphQL
       def after_any_lazies(maybe_lazies)
         if maybe_lazies.any? { |l| lazy?(l) }
           GraphQL::Execution::Lazy.all(maybe_lazies).then do |result|
-            yield
+            yield result
           end
         else
-          yield
+          yield maybe_lazies
         end
       end
     end
@@ -872,8 +870,8 @@ module GraphQL
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
-      def to_json(*args)
-        JSON.pretty_generate(as_json(*args))
+      def to_json(**args)
+        JSON.pretty_generate(as_json(**args))
       end
 
       # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.

data/lib/graphql/schema/base_64_encoder.rb

@@ -13,6 +13,8 @@ module GraphQL
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
         Base64Bp.urlsafe_decode64(encoded_text)
+      rescue ArgumentError
+        raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end
     end
   end

data/lib/graphql/schema/field.rb

@@ -47,6 +47,11 @@ module GraphQL
         @resolver_class
       end
 
+      # @return [Boolean] Is this field a predefined introspection field?
+      def introspection?
+        @introspection
+      end
+
       alias :mutation :resolver
 
       # @return [Boolean] Apply tracing to this field? (Default: skip scalars, this is the override value)
@@ -663,7 +668,7 @@ module GraphQL
               loaded_value = if loads && !arg_defn.from_resolver?
                 if arg_defn.type.list?
                   loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
-                  maybe_lazies.concat(loaded_values)
+                  field_ctx.schema.after_any_lazies(loaded_values) { |result| result }
                 else
                   load_application_object(arg_defn, loads, value, field_ctx.query.context)
                 end

data/lib/graphql/schema/input_object.rb

@@ -10,12 +10,13 @@ module GraphQL
 
       include GraphQL::Dig
 
-      def initialize(values = nil, ruby_kwargs: nil, context:, defaults_used:)
+      def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
         if ruby_kwargs
           @ruby_style_hash = ruby_kwargs
+          @arguments = arguments
         else
-          @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
+          @arguments = self.class.arguments_class.new(arguments, context: context, defaults_used: defaults_used)
           # Symbolized, underscored hash:
           @ruby_style_hash = @arguments.to_kwargs
         end
@@ -56,7 +57,7 @@ module GraphQL
       # @return [GraphQL::Query::Context] The context for this query
       attr_reader :context
 
-      # @return [GraphQL::Query::Arguments] The underlying arguments instance
+      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
       attr_reader :arguments
 
       # Ruby-like hash behaviors, read-only
@@ -208,10 +209,12 @@ module GraphQL
             return nil
           end
 
-          input_values = coerce_arguments(nil, value, ctx)
+          arguments = coerce_arguments(nil, value, ctx)
 
-          input_obj_instance = self.new(ruby_kwargs: input_values, context: ctx, defaults_used: nil)
-          input_obj_instance.prepare
+          ctx.schema.after_lazy(arguments) do |resolved_arguments|
+            input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
+            input_obj_instance.prepare
+          end
         end
 
         # It's funny to think of a _result_ of an input object.

data/lib/graphql/schema/member/has_arguments.rb

@@ -63,10 +63,12 @@ module GraphQL
           self.class.argument_class(new_arg_class)
         end
 
+        # @api private
         # @param values [Hash<String, Object>]
         # @param context [GraphQL::Query::Context]
-        # @return Hash<Symbol, Object>
+        # @return [Hash<Symbol, Object>, Execution::Lazy<Hash>]
         def coerce_arguments(parent_object, values, context)
+          argument_values = {}
           kwarg_arguments = {}
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
@@ -75,6 +77,7 @@ module GraphQL
           arg_lazies = arg_defns.map do |arg_name, arg_defn|
             arg_key = arg_defn.keyword
             has_value = false
+            default_used = false
             if values.key?(arg_name)
               has_value = true
               value = values[arg_name]
@@ -84,6 +87,7 @@ module GraphQL
             elsif arg_defn.default_value?
               has_value = true
               value = arg_defn.default_value
+              default_used = true
             end
 
             if has_value
@@ -91,33 +95,43 @@ module GraphQL
               loaded_value = nil
               if loads && !arg_defn.from_resolver?
                 loaded_value = if arg_defn.type.list?
-                  value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                  context.schema.after_any_lazies(loaded_values) { |result| result }
                 else
                   load_application_object(arg_defn, loads, value, context)
                 end
               end
 
-              context.schema.after_lazy(loaded_value) do |loaded_value|
-                coerced_value = nil
-                prepared_value = context.schema.error_handler.with_error_handling(context) do
-
-                  coerced_value = if loaded_value
-                    loaded_value
-                  else
-                    arg_defn.type.coerce_input(value, context)
-                  end
+              coerced_value = if loaded_value
+                loaded_value
+              else
+                context.schema.error_handler.with_error_handling(context) do
+                  arg_defn.type.coerce_input(value, context)
+                end
+              end
 
+              context.schema.after_lazy(coerced_value) do |coerced_value|
+                prepared_value = context.schema.error_handler.with_error_handling(context) do
                   arg_defn.prepare_value(parent_object, coerced_value, context: context)
                 end
 
-                kwarg_arguments[arg_defn.keyword] = prepared_value
+                kwarg_arguments[arg_key] = prepared_value
+                # TODO code smell to access such a deeply-nested constant in a distant module
+                argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+                  value: prepared_value,
+                  definition: arg_defn,
+                  default_used: default_used,
+                )
               end
             end
           end
 
           maybe_lazies.concat(arg_lazies)
           context.schema.after_any_lazies(maybe_lazies) do
-            kwarg_arguments
+            GraphQL::Execution::Interpreter::Arguments.new(
+              keyword_arguments: kwarg_arguments,
+              argument_values: argument_values,
+            )
           end
         end
 

data/lib/graphql/schema/object.rb

@@ -79,14 +79,14 @@ module GraphQL
                 raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
-              new_memberships << int.type_membership_class.new(int, self, options)
+              new_memberships << int.type_membership_class.new(int, self, **options)
 
               # Include the methods here,
               # `.fields` will use the inheritance chain
               # to find inherited fields
               include(int)
             elsif int.is_a?(GraphQL::InterfaceType)
-              new_memberships << int.type_membership_class.new(int, self, options)
+              new_memberships << int.type_membership_class.new(int, self, **options)
             elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
               if options.any?
                 raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."

data/lib/graphql/schema/resolver.rb

@@ -220,7 +220,7 @@ module GraphQL
         # or use it as a configuration method to assign a return type
         # instead of generating one.
         # TODO unify with {#null}
-        # @param new_type [Class, nil] If a type definition class is provided, it will be used as the return type of the field
+        # @param new_type [Class, Array<Class>, nil] If a type definition class is provided, it will be used as the return type of the field
         # @param null [true, false] Whether or not the field may return `nil`
         # @return [Class] The type which this field returns.
         def type(new_type = nil, null: nil)

data/lib/graphql/tracing.rb

@@ -63,8 +63,9 @@ module GraphQL
       # @param key [String] The name of the event in GraphQL internals
       # @param metadata [Hash] Event-related metadata (can be anything)
       # @return [Object] Must return the value of the block
-      def trace(key, metadata)
-        call_tracers(0, key, metadata) { yield }
+      def trace(key, metadata, &block)
+        return yield if @tracers.empty?
+        call_tracers(0, key, metadata, &block)
       end
 
       private
@@ -76,11 +77,11 @@ module GraphQL
       # @param key [String] The current event name
       # @param metadata [Object] The current event object
       # @return Whatever the block returns
-      def call_tracers(idx, key, metadata)
+      def call_tracers(idx, key, metadata, &block)
         if idx == @tracers.length
           yield
         else
-          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata) { yield } }
+          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata, &block) }
         end
       end
     end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.10.7"
+  VERSION = "1.10.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.7
+  version: 1.10.8
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-16 00:00:00.000000000 Z
+date: 2020-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -422,6 +422,8 @@ files:
 - lib/graphql/execution/flatten.rb
 - lib/graphql/execution/instrumentation.rb
 - lib/graphql/execution/interpreter.rb
+- lib/graphql/execution/interpreter/argument_value.rb
+- lib/graphql/execution/interpreter/arguments.rb
 - lib/graphql/execution/interpreter/arguments_cache.rb
 - lib/graphql/execution/interpreter/execution_errors.rb
 - lib/graphql/execution/interpreter/handles_raw_value.rb
@@ -746,7 +748,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby