graphql 2.0.11 → 2.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9467c38d77e2174c83c1f74c8d4450cea047a5b4f8421b7c6c78323142c86c1
-  data.tar.gz: 9b93dfe4b8e72ff80f25d6cd20d897d73a32ae423439d819f810c8db6d265165
+  metadata.gz: 3d299fcfe61f486f9370dac7dfcd66df417ca4697932d7861822fb12c61a5889
+  data.tar.gz: 45e03854d6248c63f80d3b80e141a28970303516ab5f78375d9d3362b9e04ba5
 SHA512:
-  metadata.gz: 9cfce211f91fe24a0023add3f1e9e30e8ad66081c65d897053be6af6832bd8c413433a3a1721b6ccb5e670c91365d73d49b5d0c9912875b828860783536004a0
-  data.tar.gz: 3ce2af311a09a7a14ba52386049640f8b34636b8380dcfba9874745e348bc30ef2bcec58ed783897c39447379b774b3e8e5b690c477223d9532092b7c0b13112
+  metadata.gz: d756a4c5213a8e17910233b0e472a037b6dad007676f5399f6192b93df53e78611915bd066ac619b59d7d44a0f35efbd7bb329cb4189246bce0c077f584b049b
+  data.tar.gz: 277f7623f5bcc351bed49b3e95156166e16a92c3041a905f1e88399b15839eff8a0c733c16f4ae33c82213a4a47c3184d5c763e43ac2ca01a613caa419000513

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

@@ -685,12 +685,16 @@ module GraphQL
             set_result(selection_result, result_name, r)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy, resolved_value = resolve_type(current_type, value, path)
-            resolved_value ||= value
+            resolved_type_or_lazy = resolve_type(current_type, value, path)
+            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |resolved_type_result|
+              if resolved_type_result.is_a?(Array) && resolved_type_result.length == 2
+                resolved_type, resolved_value = resolved_type_result
+              else
+                resolved_type = resolved_type_result
+                resolved_value = value
+              end
 
-            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |resolved_type|
               possible_types = query.possible_types(current_type)
-
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
                 err_class = current_type::UnresolvedTypeError

data/lib/graphql/language/printer.rb

@@ -236,12 +236,15 @@ module GraphQL
         out = print_description(input_object_type)
         out << "input #{input_object_type.name}"
         out << print_directives(input_object_type.directives)
-        out << " {\n"
-        input_object_type.fields.each.with_index do |field, i|
-          out << print_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{print_input_value_definition(field)}\n"
+        if !input_object_type.fields.empty?
+          out << " {\n"
+          input_object_type.fields.each.with_index do |field, i|
+            out << print_description(field, indent: '  ', first_in_block: i == 0)
+            out << "  #{print_input_value_definition(field)}\n"
+          end
+          out << "}"
         end
-        out << "}"
+        out
       end
 
       def print_directive_definition(directive)

data/lib/graphql/query/validation_pipeline.rb

@@ -45,6 +45,10 @@ module GraphQL
         @query_analyzers
       end
 
+      def has_validated?
+        @has_validated == true
+      end
+
       private
 
       # If the pipeline wasn't run yet, run it.

data/lib/graphql/query.rb

@@ -34,7 +34,16 @@ module GraphQL
     attr_accessor :operation_name
 
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
-    attr_accessor :validate
+    attr_reader :validate
+
+    # @param new_validate [Boolean] if false, static validation is skipped. This can't be reasssigned after validation.
+    def validate=(new_validate)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#validate= after validation has run, remove this assignment."
+      else
+        @validate = new_validate
+      end
+    end
 
     attr_writer :query_string
 

data/lib/graphql/schema/argument.rb

@@ -259,26 +259,26 @@ module GraphQL
         # 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 |resolved_coerced_value|
+          owner.validate_directive_argument(self, resolved_coerced_value)
+          prepared_value = begin
+            prepare_value(parent_object, resolved_coerced_value, context: context)
+          rescue StandardError => err
+            context.schema.handle_or_reraise(context, err)
+          end
+
           if loads && !from_resolver?
             loaded_value = begin
-              load_and_authorize_value(owner, coerced_value, context)
+              load_and_authorize_value(owner, prepared_value, context)
             rescue StandardError => err
               context.schema.handle_or_reraise(context, err)
             end
           end
 
-          maybe_loaded_value = loaded_value || resolved_coerced_value
+          maybe_loaded_value = loaded_value || prepared_value
           context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
-            owner.validate_directive_argument(self, resolved_loaded_value)
-            prepared_value = begin
-              prepare_value(parent_object, resolved_loaded_value, context: context)
-            rescue StandardError => err
-              context.schema.handle_or_reraise(context, err)
-            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,
+              value: resolved_loaded_value,
               definition: self,
               default_used: default_used,
             )

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

@@ -323,8 +323,14 @@ module GraphQL
               end
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
-              resolved_application_object_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
+              maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
+              context.schema.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+                if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
+                  application_object_type, application_object = resolve_type_result
+                else
+                  application_object_type = resolve_type_result
+                  # application_object is already assigned
+                end
                 possible_object_types = context.warden.possible_types(argument.loads)
                 if !possible_object_types.include?(application_object_type)
                   err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)

data/lib/graphql/schema.rb

@@ -754,13 +754,21 @@ module GraphQL
       # rubocop:disable Lint/DuplicateMethods
       module ResolveTypeWithType
         def resolve_type(type, obj, ctx)
-          first_resolved_type, resolved_value = if type.is_a?(Module) && type.respond_to?(:resolve_type)
+          maybe_lazy_resolve_type_result = if type.is_a?(Module) && type.respond_to?(:resolve_type)
             type.resolve_type(obj, ctx)
           else
             super
           end
 
-          after_lazy(first_resolved_type) do |resolved_type|
+          after_lazy(maybe_lazy_resolve_type_result) do |resolve_type_result|
+            if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
+              resolved_type = resolve_type_result[0]
+              resolved_value = resolve_type_result[1]
+            else
+              resolved_type = resolve_type_result
+              resolved_value = obj
+            end
+
             if resolved_type.nil? || (resolved_type.is_a?(Module) && resolved_type.respond_to?(:kind))
               if resolved_value
                 [resolved_type, resolved_value]

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.11
+  version: 2.0.12
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-20 00:00:00.000000000 Z
+date: 2022-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips