graphql 1.12.6 → 1.12.11

data/lib/graphql/schema/resolver.rb

@@ -333,30 +333,32 @@ module GraphQL
           arg_defn = super(*args, from_resolver: true, **kwargs)
           own_arguments_loads_as_type[arg_defn.keyword] = loads if loads
 
-          if loads && arg_defn.type.list?
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(values)
-              argument = @arguments_by_keyword[:#{arg_defn.keyword}]
-              lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
-              context.schema.after_lazy(values) do |values2|
-                GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value, context) })
+          if !method_defined?(:"load_#{arg_defn.keyword}")
+            if loads && arg_defn.type.list?
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(values)
+                argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+                lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+                context.schema.after_lazy(values) do |values2|
+                  GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value, context) })
+                end
               end
+              RUBY
+            elsif loads
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(value)
+                argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+                lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+                load_application_object(argument, lookup_as_type, value, context)
+              end
+              RUBY
+            else
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(value)
+                value
+              end
+              RUBY
             end
-            RUBY
-          elsif loads
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(value)
-              argument = @arguments_by_keyword[:#{arg_defn.keyword}]
-              lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
-              load_application_object(argument, lookup_as_type, value, context)
-            end
-            RUBY
-          else
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(value)
-              value
-            end
-            RUBY
           end
 
           arg_defn
@@ -372,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/schema/scalar.rb

@@ -44,7 +44,9 @@ module GraphQL
         def validate_non_null_input(value, ctx)
           result = Query::InputValidationResult.new
           coerced_result = begin
-            coerce_input(value, ctx)
+            ctx.query.with_error_handling do
+              coerce_input(value, ctx)
+            end
           rescue GraphQL::CoercionError => err
             err
           end

data/lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -41,7 +41,9 @@ module GraphQL
               error_options = {
                 nodes: parent,
                 type: kind_of_node,
-                argument: node.name
+                argument_name: node.name,
+                argument: arg_defn,
+                value: node.value
               }
               if coerce_extensions
                 error_options[:coerce_extensions] = coerce_extensions

data/lib/graphql/static_validation/rules/argument_literals_are_compatible_error.rb

@@ -4,13 +4,17 @@ module GraphQL
     class ArgumentLiteralsAreCompatibleError < StaticValidation::Error
       attr_reader :type_name
       attr_reader :argument_name
+      attr_reader :argument
+      attr_reader :value
 
-      def initialize(message, path: nil, nodes: [], type:, argument: nil, extensions: nil, coerce_extensions: nil)
+      def initialize(message, path: nil, nodes: [], type:, argument_name: nil, extensions: nil, coerce_extensions: nil, argument: nil, value: nil)
         super(message, path: path, nodes: nodes)
         @type_name = type
-        @argument_name = argument
+        @argument_name = argument_name
         @extensions = extensions
         @coerce_extensions = coerce_extensions
+        @argument = argument
+        @value = value
       end
 
       # A hash representation of this Message

data/lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -15,7 +15,8 @@ module GraphQL
             nodes: node,
             name: error_arg_name,
             type: kind_of_node,
-            argument: node.name
+            argument_name: node.name,
+            parent: parent_defn
           ))
         else
           # Some other weird error

data/lib/graphql/static_validation/rules/arguments_are_defined_error.rb

@@ -5,12 +5,14 @@ module GraphQL
       attr_reader :name
       attr_reader :type_name
       attr_reader :argument_name
+      attr_reader :parent
 
-      def initialize(message, path: nil, nodes: [], name:, type:, argument:)
+      def initialize(message, path: nil, nodes: [], name:, type:, argument_name:, parent:)
         super(message, path: path, nodes: nodes)
         @name = name
         @type_name = type
-        @argument_name = argument
+        @argument_name = argument_name
+        @parent = parent
       end
 
       # A hash representation of this Message

data/lib/graphql/static_validation/rules/directives_are_defined.rb

@@ -4,7 +4,7 @@ module GraphQL
     module DirectivesAreDefined
       def initialize(*)
         super
-        @directive_names = context.schema.directives.keys
+        @directive_names = context.warden.directives.map(&:graphql_name)
       end
 
       def on_directive(node, parent)

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -373,17 +373,26 @@ module GraphQL
       # In this context, `parents` represends the "self scope" of the field,
       # what types may be found at this point in the query.
       def mutually_exclusive?(parents1, parents2)
-        parents1.each do |type1|
-          parents2.each do |type2|
-            # If the types we're comparing are both different object types,
-            # they have to be mutually exclusive.
-            if type1 != type2 && type1.kind.object? && type2.kind.object?
-              return true
+        if parents1.empty? || parents2.empty?
+          false
+        elsif parents1.length == parents2.length
+          parents1.length.times.any? do |i|
+            type1 = parents1[i - 1]
+            type2 = parents2[i - 1]
+            if type1 == type2
+              # If the types we're comparing are the same type,
+              # then they aren't mutually exclusive
+              false
+            else
+              # Check if these two scopes have _any_ types in common.
+              possible_right_types = context.query.possible_types(type1)
+              possible_left_types = context.query.possible_types(type2)
+              (possible_right_types & possible_left_types).empty?
             end
           end
+        else
+          true
         end
-
-        false
       end
     end
   end

data/lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb

@@ -23,7 +23,7 @@ module GraphQL
         defn = if arg_defn && arg_defn.type.unwrap.kind.input_object?
           arg_defn.type.unwrap
         else
-          context.field_definition
+          context.directive_definition || context.field_definition
         end
 
         parent_type = context.warden.get_argument(defn, parent_name(parent, defn))

data/lib/graphql/static_validation/validator.rb

@@ -73,6 +73,11 @@ module GraphQL
             irep: irep,
           }
         end
+      rescue GraphQL::ExecutionError => e
+        {
+          errors: [e],
+          irep: nil,
+        }
       end
 
       # Invoked when static validation times out.

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -34,12 +34,12 @@ module GraphQL
     #         channel: self,
     #       }
     #
-    #       result = MySchema.execute({
+    #       result = MySchema.execute(
     #         query: query,
     #         context: context,
     #         variables: variables,
     #         operation_name: operation_name
-    #       })
+    #       )
     #
     #       payload = {
     #         result: result.to_h,
@@ -146,14 +146,15 @@ module GraphQL
       def setup_stream(channel, initial_event)
         topic = initial_event.topic
         channel.stream_from(stream_event_name(initial_event), coder: @action_cable_coder) do |message|
-          object = @serializer.load(message)
           events_by_fingerprint = @events[topic]
+          object = nil
           events_by_fingerprint.each do |_fingerprint, events|
             if events.any? && events.first == initial_event
               # The fingerprint has told us that this response should be shared by all subscribers,
               # so just run it once, then deliver the result to every subscriber
               first_event = events.first
               first_subscription_id = first_event.context.fetch(:subscription_id)
+              object ||= @serializer.load(message)
               result = execute_update(first_subscription_id, first_event, object)
               # Having calculated the result _once_, send the same payload to all subscribers
               events.each do |event|

data/lib/graphql/subscriptions/broadcast_analyzer.rb

@@ -35,9 +35,6 @@ module GraphQL
           pt = @query.possible_types(current_type)
           pt.each do |object_type|
             ot_field = @query.get_field(object_type, current_field.graphql_name)
-            if !ot_field
-              binding.pry
-            end
             # Inherited fields would be exactly the same object;
             # only check fields that are overrides of the inherited one
             if ot_field && ot_field != current_field

data/lib/graphql/subscriptions/serialize.rb

@@ -55,7 +55,14 @@ module GraphQL
         # @return [Object] An object that load Global::Identification recursive
         def load_value(value)
           if value.is_a?(Array)
-            value.map{|item| load_value(item)}
+            is_gids = (v1 = value[0]).is_a?(Hash) && v1.size == 1 && v1[GLOBALID_KEY]
+            if is_gids
+              # Assume it's an array of global IDs
+              ids = value.map { |v| v[GLOBALID_KEY] }
+              GlobalID::Locator.locate_many(ids)
+            else
+              value.map { |item| load_value(item) }
+            end
           elsif value.is_a?(Hash)
             if value.size == 1
               case value.keys.first # there's only 1 key
@@ -70,6 +77,9 @@ module GraphQL
               when OPEN_STRUCT_KEY
                 ostruct_values = load_value(value[OPEN_STRUCT_KEY])
                 OpenStruct.new(ostruct_values)
+              else
+                key = value.keys.first
+                { key => load_value(value[key]) }
               end
             else
               loaded_h = {}

data/lib/graphql/types/relay/base_connection.rb

@@ -24,6 +24,10 @@ module GraphQL
       #   end
       #   class Types::PostConnection < Types::BaseConnection
       #     edge_type(Types::PostEdge)
+      #     edges_nullable(true)
+      #     edge_nullable(true)
+      #     node_nullable(true)
+      #     has_nodes_field(true)
       #   end
       #
       # @see Relay::BaseEdge for edge types

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -11,6 +11,7 @@ module GraphQL
           child_class.extend(ClassMethods)
           child_class.extend(Relay::DefaultRelay)
           child_class.default_relay(true)
+          child_class.has_nodes_field(true)
           child_class.node_nullable(true)
           child_class.edges_nullable(true)
           child_class.edge_nullable(true)
@@ -34,7 +35,7 @@ module GraphQL
           # It's called when you subclass this base connection, trying to use the
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable)
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -79,9 +80,9 @@ module GraphQL
           # Use `node_nullable(false)` in your base class to make non-null `node` and `nodes` fields.
           def node_nullable(new_value = nil)
             if new_value.nil?
-              @node_nullable || superclass.node_nullable
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
             else
-              @node_nullable ||= new_value
+              @node_nullable = new_value
             end
           end
 
@@ -89,21 +90,31 @@ module GraphQL
           # Use `edges_nullable(false)` in your base class to make non-null `edges` fields.
           def edges_nullable(new_value = nil)
             if new_value.nil?
-              @edges_nullable || superclass.edges_nullable
+              defined?(@edges_nullable) ? @edges_nullable : superclass.edges_nullable
             else
-              @edges_nullable ||= new_value
+              @edges_nullable = new_value
             end
-          end     
-          
+          end
+
           # Set the default `edge_nullable` for this class and its child classes. (Defaults to `true`.)
           # Use `edge_nullable(false)` in your base class to make non-null `edge` fields.
           def edge_nullable(new_value = nil)
             if new_value.nil?
-              @edge_nullable || superclass.edge_nullable
+              defined?(@edge_nullable) ? @edge_nullable : superclass.edge_nullable
+            else
+              @edge_nullable = new_value
+            end
+          end
+
+          # Set the default `nodes_field` for this class and its child classes. (Defaults to `true`.)
+          # Use `nodes_field(false)` in your base class to prevent adding of a nodes field.
+          def has_nodes_field(new_value = nil)
+            if new_value.nil?
+              defined?(@nodes_field) ? @nodes_field : superclass.has_nodes_field
             else
-              @edge_nullable ||= new_value
+              @nodes_field = new_value
             end
-          end               
+          end
 
           private
 

data/lib/graphql/types/relay/edge_behaviors.rb

@@ -8,6 +8,7 @@ module GraphQL
           child_class.description("An edge in a connection.")
           child_class.field(:cursor, String, null: false, description: "A cursor for use in pagination.")
           child_class.extend(ClassMethods)
+          child_class.node_nullable(true)
         end
 
         module ClassMethods
@@ -15,7 +16,7 @@ module GraphQL
           #
           # @param node_type [Class] A `Schema::Object` subclass
           # @param null [Boolean]
-          def node_type(node_type = nil, null: true)
+          def node_type(node_type = nil, null: self.node_nullable)
             if node_type
               @node_type = node_type
               # Add a default `node` field
@@ -35,6 +36,16 @@ module GraphQL
           def visible?(ctx)
             node_type.visible?(ctx)
           end
+
+          # Set the default `node_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `node_nullable(false)` in your base class to make non-null `node` field.
+          def node_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
+            else
+              @node_nullable = new_value
+            end
+          end
         end
       end
     end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.6
+  version: 1.12.11
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-11 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