graphql 1.12.10 → 1.12.11

data/lib/graphql/schema/argument.rb

@@ -240,62 +240,79 @@ module GraphQL
       def coerce_into_values(parent_object, values, context, argument_values)
         arg_name = graphql_name
         arg_key = keyword
-        has_value = false
         default_used = false
+
         if values.key?(arg_name)
-          has_value = true
           value = values[arg_name]
         elsif values.key?(arg_key)
-          has_value = true
           value = values[arg_key]
         elsif default_value?
-          has_value = true
           value = default_value
           default_used = true
+        else
+          # no value at all
+          owner.validate_directive_argument(self, nil)
+          return
         end
 
-        if has_value
-          loaded_value = nil
-          coerced_value = context.schema.error_handler.with_error_handling(context) do
-            type.coerce_input(value, context)
-          end
+        loaded_value = nil
+        coerced_value = context.schema.error_handler.with_error_handling(context) do
+          type.coerce_input(value, context)
+        end
 
-          # TODO this should probably be inside after_lazy
-          if loads && !from_resolver?
-            loaded_value = if type.list?
-              loaded_values = coerced_value.map { |val| owner.load_application_object(self, loads, val, context) }
-              context.schema.after_any_lazies(loaded_values) { |result| result }
-            else
-              context.query.with_error_handling do
-                owner.load_application_object(self, loads, coerced_value, context)
-              end
+        # TODO this should probably be inside after_lazy
+        if loads && !from_resolver?
+          loaded_value = if type.list?
+            loaded_values = coerced_value.map { |val| owner.load_application_object(self, loads, val, context) }
+            context.schema.after_any_lazies(loaded_values) { |result| result }
+          else
+            context.query.with_error_handling do
+              owner.load_application_object(self, loads, coerced_value, context)
             end
           end
+        end
 
-          coerced_value = if loaded_value
-            loaded_value
-          else
-            coerced_value
+        coerced_value = if loaded_value
+          loaded_value
+        else
+          coerced_value
+        end
+
+        # If this isn't lazy, then the block returns eagerly and assigns the result here
+        # If it _is_ lazy, then we write the lazy to the hash, then update it later
+        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |coerced_value|
+          owner.validate_directive_argument(self, coerced_value)
+          prepared_value = context.schema.error_handler.with_error_handling(context) do
+            prepare_value(parent_object, coerced_value, context: context)
           end
 
-          # If this isn't lazy, then the block returns eagerly and assigns the result here
-          # If it _is_ lazy, then we write the lazy to the hash, then update it later
-          argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |coerced_value|
-            owner.validate_directive_argument(self, coerced_value)
-            prepared_value = context.schema.error_handler.with_error_handling(context) do
-              prepare_value(parent_object, coerced_value, context: context)
-            end
+          # 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: self,
+            default_used: default_used,
+          )
+        end
+      end
 
-            # 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: self,
-              default_used: default_used,
-            )
-          end
-        else
-          # has_value is false
-          owner.validate_directive_argument(self, nil)
+      # @api private
+      def validate_default_value
+        coerced_default_value = begin
+          type.coerce_isolated_result(default_value) unless default_value.nil?
+        rescue GraphQL::Schema::Enum::UnresolvedValueError
+          # It raises this, which is helpful at runtime, but not here...
+          default_value
+        end
+        res = type.valid_isolated_input?(coerced_default_value)
+        if !res
+          raise InvalidDefaultValueError.new(self)
+        end
+      end
+
+      class InvalidDefaultValueError < GraphQL::Error
+        def initialize(argument)
+          message = "`#{argument.path}` has an invalid default value: `#{argument.default_value.inspect}` isn't accepted by `#{argument.type.to_type_signature}`; update the default value or the argument type."
+          super(message)
         end
       end
 

data/lib/graphql/schema/directive/transform.rb

@@ -39,7 +39,19 @@ module GraphQL
           transform_name = arguments[:by]
           if TRANSFORMS.include?(transform_name) && return_value.respond_to?(transform_name)
             return_value = return_value.public_send(transform_name)
-            context.namespace(:interpreter)[:runtime].write_in_response(path, return_value)
+            response = context.namespace(:interpreter)[:runtime].response
+            *keys, last = path
+            keys.each do |key|
+              if response && (response = response[key])
+                next
+              else
+                break
+              end
+            end
+            if response
+              response[last] = return_value
+            end
+            nil
           end
         end
       end

data/lib/graphql/schema/resolver.rb

@@ -374,16 +374,36 @@ module GraphQL
         # @param extension [Class] Extension class
         # @param options [Hash] Optional extension options
         def extension(extension, **options)
-          extensions << {extension => options}
+          @own_extensions ||= []
+          @own_extensions << {extension => options}
         end
 
         # @api private
         def extensions
-          @extensions ||= []
+          own_exts = @own_extensions
+          # Jump through some hoops to avoid creating arrays when we don't actually need them
+          if superclass.respond_to?(:extensions)
+            s_exts = superclass.extensions
+            if own_exts
+              if s_exts.any?
+                own_exts + s_exts
+              else
+                own_exts
+              end
+            else
+              s_exts
+            end
+          else
+            own_exts || EMPTY_ARRAY
+          end
         end
 
         private
 
+        def own_extensions
+          @own_extensions
+        end
+
         def own_arguments_loads_as_type
           @own_arguments_loads_as_type ||= {}
         end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.10
+  version: 1.12.11
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-18 00:00:00.000000000 Z
+date: 2021-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -369,7 +369,6 @@ files:
 - lib/graphql/execution/interpreter/arguments_cache.rb
 - lib/graphql/execution/interpreter/execution_errors.rb
 - lib/graphql/execution/interpreter/handles_raw_value.rb
-- lib/graphql/execution/interpreter/hash_response.rb
 - lib/graphql/execution/interpreter/resolve.rb
 - lib/graphql/execution/interpreter/runtime.rb
 - lib/graphql/execution/lazy.rb
@@ -485,6 +484,7 @@ files:
 - lib/graphql/runtime_type_error.rb
 - lib/graphql/scalar_type.rb
 - lib/graphql/schema.rb
+- lib/graphql/schema/addition.rb
 - lib/graphql/schema/argument.rb
 - lib/graphql/schema/base_64_bp.rb
 - lib/graphql/schema/base_64_encoder.rb
@@ -699,7 +699,7 @@ metadata:
   source_code_uri: https://github.com/rmosolgo/graphql-ruby
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
   mailing_list_uri: https://tinyletter.com/graphql-ruby
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -714,8 +714,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Execution
-    class Interpreter
-      # This response class handles `#write` by accumulating
-      # values into a Hash.
-      class HashResponse
-        def initialize
-          @result = {}
-        end
-
-        def final_value
-          @result
-        end
-
-        def inspect
-          "#<#{self.class.name} result=#{@result.inspect}>"
-        end
-
-        # Add `value` at `path`.
-        # @return [void]
-        def write(path, value)
-          if path.empty?
-            @result = value
-          elsif (write_target = @result)
-            i = 0
-            prefinal_steps = path.size - 1
-            # Use `while` to avoid a closure
-            while i < prefinal_steps
-              path_part = path[i]
-              i += 1
-              write_target = write_target[path_part]
-            end
-            path_part = path[i]
-            write_target[path_part] = value
-          else
-            # The response is completely nulled out
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end