graphql 1.12.3 → 1.12.8

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

@@ -81,79 +81,66 @@ module GraphQL
         end
 
         # @api private
+        # If given a block, it will eventually yield the loaded args to the block.
+        #
+        # If no block is given, it will immediately dataload (but might return a Lazy).
+        #
         # @param values [Hash<String, Object>]
         # @param context [GraphQL::Query::Context]
-        # @return [Hash<Symbol, Object>, Execution::Lazy<Hash>]
-        def coerce_arguments(parent_object, values, context)
+        # @yield [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
+          total_args_count = arg_defns.size
 
-          if arg_defns.empty?
-            GraphQL::Execution::Interpreter::Arguments::EMPTY
+          if total_args_count == 0
+            final_args = GraphQL::Execution::Interpreter::Arguments::EMPTY
+            if block_given?
+              block.call(final_args)
+              nil
+            else
+              final_args
+            end
           else
+            finished_args = nil
             argument_values = {}
-            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]
-              elsif values.key?(arg_key)
-                has_value = true
-                value = values[arg_key]
-              elsif arg_defn.default_value?
-                has_value = true
-                value = arg_defn.default_value
-                default_used = true
-              end
-
-              if has_value
-                loads = arg_defn.loads
-                loaded_value = nil
-                coerced_value = context.schema.error_handler.with_error_handling(context) do
-                  arg_defn.type.coerce_input(value, context)
-                end
-
-                # TODO this should probably be inside after_lazy
-                if loads && !arg_defn.from_resolver?
-                  loaded_value = if arg_defn.type.list?
-                    loaded_values = coerced_value.map { |val| load_application_object(arg_defn, loads, val, context) }
-                    context.schema.after_any_lazies(loaded_values) { |result| result }
+            resolved_args_count = 0
+            raised_error = false
+            arg_defns.each do |arg_name, arg_defn|
+              context.dataloader.append_job do
+                begin
+                  arg_defn.coerce_into_values(parent_object, values, context, argument_values)
+                rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
+                  raised_error = true
+                  if block_given?
+                    block.call(err)
                   else
-                    load_application_object(arg_defn, loads, coerced_value, context)
+                    finished_args = err
                   end
                 end
 
-                coerced_value = if loaded_value
-                  loaded_value
-                else
-                  coerced_value
-                end
+                resolved_args_count += 1
+                if resolved_args_count == total_args_count && !raised_error
+                  finished_args = context.schema.after_any_lazies(argument_values.values) {
+                    GraphQL::Execution::Interpreter::Arguments.new(
+                      argument_values: argument_values,
+                    )
+                  }
 
-                context.schema.after_lazy(coerced_value) do |coerced_value|
-                  validate_directive_argument(arg_defn, coerced_value)
-                  prepared_value = context.schema.error_handler.with_error_handling(context) do
-                    arg_defn.prepare_value(parent_object, coerced_value, context: context)
+                  if block_given?
+                    block.call(finished_args)
                   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: arg_defn,
-                    default_used: default_used,
-                  )
                 end
-              else
-                # has_value is false
-                validate_directive_argument(arg_defn, nil)
               end
             end
 
-            context.schema.after_any_lazies(arg_lazies) do
-              GraphQL::Execution::Interpreter::Arguments.new(
-                argument_values: argument_values,
-              )
+            if block_given?
+              nil
+            else
+              # This API returns eagerly, gotta run it now
+              context.dataloader.run
+              finished_args
             end
           end
         end

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

@@ -74,11 +74,8 @@ module GraphQL
             @field_class = new_field_class
           elsif defined?(@field_class) && @field_class
             @field_class
-          elsif self.is_a?(Class)
-            superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field
           else
-            ancestor = ancestors[1..-1].find { |a| a.respond_to?(:field_class) && a.field_class }
-            ancestor ? ancestor.field_class : GraphQL::Schema::Field
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../object.rb
 
 module GraphQL
   class Schema

data/lib/graphql/schema/resolver.rb

@@ -276,8 +276,29 @@ module GraphQL
           end
         end
 
+        # Get or set the `max_page_size:` which will be configured for fields using this resolver
+        # (`nil` means "unlimited max page size".)
+        # @param max_page_size [Integer, nil] Set a new value
+        # @return [Integer, nil] The `max_page_size` assigned to fields that use this resolver
+        def max_page_size(new_max_page_size = :not_given)
+          if new_max_page_size != :not_given
+            @max_page_size = new_max_page_size
+          elsif defined?(@max_page_size)
+            @max_page_size
+          elsif superclass.respond_to?(:max_page_size)
+            superclass.max_page_size
+          else
+            nil
+          end
+        end
+
+        # @return [Boolean] `true` if this resolver or a superclass has an assigned `max_page_size`
+        def has_max_page_size?
+          defined?(@max_page_size) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
+        end
+
         def field_options
-          {
+          field_opts = {
             type: type_expr,
             description: description,
             extras: extras,
@@ -289,6 +310,12 @@ module GraphQL
             extensions: extensions,
             broadcastable: broadcastable?,
           }
+
+          if has_max_page_size?
+            field_opts[:max_page_size] = max_page_size
+          end
+
+          field_opts
         end
 
         # A non-normalized type configuration, without `null` applied

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/variable_usages_are_allowed.rb

@@ -29,8 +29,8 @@ module GraphQL
             context.directive_definition.arguments
           when GraphQL::Language::Nodes::InputObject
             arg_type = context.argument_definition.type.unwrap
-            if arg_type.is_a?(GraphQL::InputObjectType)
-              arguments = arg_type.input_fields
+            if arg_type.kind.input_object?
+              arguments = arg_type.arguments
             else
               # This is some kind of error
               nil

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/event.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # This thing can be:

data/lib/graphql/subscriptions/instrumentation.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # Wrap the root fields of the subscription type with special logic for:

data/lib/graphql/subscriptions/serialize.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 require "set"
 module GraphQL
   class Subscriptions
@@ -71,6 +70,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/tracing/active_support_notifications_tracing.rb

@@ -3,8 +3,9 @@
 module GraphQL
   module Tracing
     # This implementation forwards events to ActiveSupport::Notifications
-    # with a `graphql.` prefix.
+    # with a `graphql` suffix.
     #
+    # @see KEYS for event names
     module ActiveSupportNotificationsTracing
       # A cache of frequently-used keys to avoid needless string allocations
       KEYS = {

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,7 +11,10 @@ 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)
           add_page_info_field(child_class)
         end
 
@@ -32,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)
+          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
 
@@ -40,8 +43,8 @@ module GraphQL
             @edge_type = edge_type_class
             @edge_class = edge_class
 
-            field :edges, [edge_type_class, null: true],
-              null: true,
+            field :edges, [edge_type_class, null: edge_nullable],
+              null: edges_nullable,
               description: "A list of edges.",
               legacy_edge_class: edge_class, # This is used by the old runtime only, for EdgesInstrumentation
               connection: false
@@ -77,9 +80,39 @@ 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
+
+          # Set the default `edges_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `edges_nullable(false)` in your base class to make non-null `edges` fields.
+          def edges_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@edges_nullable) ? @edges_nullable : superclass.edges_nullable
+            else
+              @edges_nullable = new_value
+            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?
+              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
+              @nodes_field = new_value
             end
           end
 

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.3"
+  VERSION = "1.12.8"
 end

data/readme.md

@@ -1,6 +1,6 @@
 # graphql <img src="https://cloud.githubusercontent.com/assets/2231765/9094460/cb43861e-3b66-11e5-9fbf-71066ff3ab13.png" height="40" alt="graphql-ruby"/>
 
-[![Build Status](https://travis-ci.org/rmosolgo/graphql-ruby.svg?branch=master)](https://travis-ci.org/rmosolgo/graphql-ruby)
+[![CI Suite](https://github.com/rmosolgo/graphql-ruby/actions/workflows/ci.yaml/badge.svg)](https://github.com/rmosolgo/graphql-ruby/actions/workflows/ci.yaml)
 [![Gem Version](https://badge.fury.io/rb/graphql.svg)](https://rubygems.org/gems/graphql)
 [![Code Climate](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/gpa.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
 [![Test Coverage](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/coverage.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)