graphql 1.13.0 → 1.13.4

data/lib/graphql/schema/field.rb

@@ -16,6 +16,8 @@ module GraphQL
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
 
+      class FieldImplementationFailed < GraphQL::Error; end
+
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
       alias :graphql_name :name
@@ -290,6 +292,7 @@ module GraphQL
         @subscription_scope = subscription_scope
 
         @extensions = EMPTY_ARRAY
+        @call_after_define = false
         # This should run before connection extension,
         # but should it run after the definition block?
         if scoped?
@@ -322,6 +325,9 @@ module GraphQL
             instance_eval(&definition_block)
           end
         end
+
+        self.extensions.each(&:after_define_apply)
+        @call_after_define = true
       end
 
       # If true, subscription updates with this field can be shared between viewers
@@ -354,27 +360,20 @@ module GraphQL
       # @example adding an extension with options
       #   extensions([MyExtensionClass, { AnotherExtensionClass => { filter: true } }])
       #
-      # @param extensions [Array<Class, Hash<Class => Object>>] Add extensions to this field. For hash elements, only the first key/value is used.
+      # @param extensions [Array<Class, Hash<Class => Hash>>] Add extensions to this field. For hash elements, only the first key/value is used.
       # @return [Array<GraphQL::Schema::FieldExtension>] extensions to apply to this field
       def extensions(new_extensions = nil)
-        if new_extensions.nil?
-          # Read the value
-          @extensions
-        else
-          if @extensions.frozen?
-            @extensions = @extensions.dup
-          end
-          new_extensions.each do |extension|
-            if extension.is_a?(Hash)
-              extension = extension.to_a[0]
-              extension_class, options = *extension
-              @extensions << extension_class.new(field: self, options: options)
+        if new_extensions
+          new_extensions.each do |extension_config|
+            if extension_config.is_a?(Hash)
+              extension_class, options = *extension_config.to_a[0]
+              self.extension(extension_class, options)
             else
-              extension_class = extension
-              @extensions << extension_class.new(field: self, options: nil)
+              self.extension(extension_config)
             end
           end
         end
+        @extensions
       end
 
       # Add `extension` to this field, initialized with `options` if provided.
@@ -385,10 +384,19 @@ module GraphQL
       # @example adding an extension with options
       #   extension(MyExtensionClass, filter: true)
       #
-      # @param extension [Class] subclass of {Schema::Fieldextension}
-      # @param options [Object] if provided, given as `options:` when initializing `extension`.
-      def extension(extension, options = nil)
-        extensions([{extension => options}])
+      # @param extension_class [Class] subclass of {Schema::FieldExtension}
+      # @param options [Hash] if provided, given as `options:` when initializing `extension`.
+      # @return [void]
+      def extension(extension_class, options = nil)
+        extension_inst = extension_class.new(field: self, options: options)
+        if @extensions.frozen?
+          @extensions = @extensions.dup
+        end
+        if @call_after_define
+          extension_inst.after_define_apply
+        end
+        @extensions << extension_inst
+        nil
       end
 
       # Read extras (as symbols) from this field,
@@ -441,10 +449,15 @@ module GraphQL
             if lookahead.selects?(:total) || lookahead.selects?(:total_count) || lookahead.selects?(:count)
               metadata_complexity += 1
             end
+
+            nodes_edges_complexity = 0
+            nodes_edges_complexity += 1 if lookahead.selects?(:edges)
+            nodes_edges_complexity += 1 if lookahead.selects?(:nodes)
+
             # Possible bug: selections on `edges` and `nodes` are _both_ multiplied here. Should they be?
-            items_complexity = child_complexity - metadata_complexity
+            items_complexity = child_complexity - metadata_complexity - nodes_edges_complexity
             # Add 1 for _this_ field
-            1 + (max_possible_page_size * items_complexity) + metadata_complexity
+            1 + (max_possible_page_size * items_complexity) + metadata_complexity + nodes_edges_complexity
           end
         else
           defined_complexity = complexity
@@ -488,6 +501,8 @@ module GraphQL
       # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
       attr_reader :max_page_size
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       # @return [GraphQL::Field]
       def to_graphql
         field_defn = if @field
@@ -543,7 +558,7 @@ module GraphQL
         field_defn.ast_node = ast_node
 
         all_argument_definitions.each do |defn|
-          arg_graphql = defn.to_graphql
+          arg_graphql = defn.deprecated_to_graphql
           field_defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
         end
 
@@ -605,7 +620,7 @@ module GraphQL
 
       def authorized?(object, args, context)
         if @resolver_class
-          # The resolver will check itself during `resolve()`
+          # The resolver _instance_ will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
           if (arg_values = context[:current_arguments])
@@ -779,51 +794,103 @@ module GraphQL
 
       def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
         with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
-          if @resolver_class
-            if obj.is_a?(GraphQL::Schema::Object)
-              obj = obj.object
-            end
-            obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
-          end
-
-          # Find a way to resolve this field, checking:
-          #
-          # - A method on the type instance;
-          # - Hash keys, if the wrapped object is a hash;
-          # - A method on the wrapped object;
-          # - Or, raise not implemented.
-          #
-          if obj.respond_to?(@resolver_method)
-            # Call the method with kwargs, if there are any
-            if ruby_kwargs.any?
-              obj.public_send(@resolver_method, **ruby_kwargs)
-            else
-              obj.public_send(@resolver_method)
+          begin
+            method_receiver = nil
+            method_to_call = nil
+            if @resolver_class
+              if obj.is_a?(GraphQL::Schema::Object)
+                obj = obj.object
+              end
+              obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
             end
-          elsif obj.object.is_a?(Hash)
-            inner_object = obj.object
-            if inner_object.key?(@method_sym)
-              inner_object[@method_sym]
+
+            # Find a way to resolve this field, checking:
+            #
+            # - A method on the type instance;
+            # - Hash keys, if the wrapped object is a hash;
+            # - A method on the wrapped object;
+            # - Or, raise not implemented.
+            #
+            if obj.respond_to?(@resolver_method)
+              method_to_call = @resolver_method
+              method_receiver = obj
+              # Call the method with kwargs, if there are any
+              if ruby_kwargs.any?
+                obj.public_send(@resolver_method, **ruby_kwargs)
+              else
+                obj.public_send(@resolver_method)
+              end
+            elsif obj.object.is_a?(Hash)
+              inner_object = obj.object
+              if inner_object.key?(@method_sym)
+                inner_object[@method_sym]
+              else
+                inner_object[@method_str]
+              end
+            elsif obj.object.respond_to?(@method_sym)
+              method_to_call = @method_sym
+              method_receiver = obj.object
+              if ruby_kwargs.any?
+                obj.object.public_send(@method_sym, **ruby_kwargs)
+              else
+                obj.object.public_send(@method_sym)
+              end
             else
-              inner_object[@method_str]
+              raise <<-ERR
+            Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+
+            - `#{obj.class}##{@resolver_method}`, which did not exist
+            - `#{obj.object.class}##{@method_sym}`, which did not exist
+            - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+
+            To implement this field, define one of the methods above (and check for typos)
+            ERR
             end
-          elsif obj.object.respond_to?(@method_sym)
-            if ruby_kwargs.any?
-              obj.object.public_send(@method_sym, **ruby_kwargs)
+          rescue ArgumentError
+            assert_satisfactory_implementation(method_receiver, method_to_call, ruby_kwargs)
+            # if the line above doesn't raise, re-raise
+            raise
+          end
+        end
+      end
+
+      def assert_satisfactory_implementation(receiver, method_name, ruby_kwargs)
+        method_defn = receiver.method(method_name)
+        unsatisfied_ruby_kwargs = ruby_kwargs.dup
+        unsatisfied_method_params = []
+        encountered_keyrest = false
+        method_defn.parameters.each do |(param_type, param_name)|
+          case param_type
+          when :key
+            unsatisfied_ruby_kwargs.delete(param_name)
+          when :keyreq
+            if unsatisfied_ruby_kwargs.key?(param_name)
+              unsatisfied_ruby_kwargs.delete(param_name)
             else
-              obj.object.public_send(@method_sym)
+              unsatisfied_method_params << "- `#{param_name}:` is required by Ruby, but not by GraphQL. Consider `#{param_name}: nil` instead, or making this argument required in GraphQL."
             end
-          else
-            raise <<-ERR
-          Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+          when :keyrest
+            encountered_keyrest = true
+          when :req
+            unsatisfied_method_params << "- `#{param_name}` is required by Ruby, but GraphQL doesn't pass positional arguments. If it's meant to be a GraphQL argument, use `#{param_name}:` instead. Otherwise, remove it."
+          when :opt, :rest
+            # This is fine, although it will never be present
+          end
+        end
+
+        if encountered_keyrest
+          unsatisfied_ruby_kwargs.clear
+        end
 
-          - `#{obj.class}##{@resolver_method}`, which did not exist
-          - `#{obj.object.class}##{@method_sym}`, which did not exist
-          - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+        if unsatisfied_ruby_kwargs.any? || unsatisfied_method_params.any?
+          raise FieldImplementationFailed.new, <<-ERR
+Failed to call #{method_name} on #{receiver.inspect} because the Ruby method params were incompatible with the GraphQL arguments:
 
-          To implement this field, define one of the methods above (and check for typos)
-          ERR
-          end
+#{ unsatisfied_ruby_kwargs
+    .map { |key, value| "- `#{key}: #{value}` was given by GraphQL but not defined in the Ruby method. Add `#{key}:` to the method parameters." }
+    .concat(unsatisfied_method_params)
+    .join("\n") }
+ERR
         end
       end
 
@@ -837,8 +904,12 @@ module GraphQL
           # This is a hack to get the _last_ value for extended obj and args,
           # in case one of the extensions doesn't `yield`.
           # (There's another implementation that uses multiple-return, but I'm wary of the perf cost of the extra arrays)
-          extended = { args: args, obj: obj, memos: nil }
+          extended = { args: args, obj: obj, memos: nil, added_extras: nil }
           value = run_extensions_before_resolve(obj, args, ctx, extended) do |obj, args|
+            if (added_extras = extended[:added_extras])
+              args = args.dup
+              added_extras.each { |e| args.delete(e) }
+            end
             yield(obj, args)
           end
 
@@ -867,6 +938,12 @@ module GraphQL
               memos = extended[:memos] ||= {}
               memos[idx] = memo
             end
+
+            if (extras = extension.added_extras)
+              ae = extended[:added_extras] ||= []
+              ae.concat(extras)
+            end
+
             extended[:obj] = extended_obj
             extended[:args] = extended_args
             run_extensions_before_resolve(extended_obj, extended_args, ctx, extended, idx: idx + 1) { |o, a| yield(o, a) }

data/lib/graphql/schema/field_extension.rb

@@ -15,23 +15,110 @@ module GraphQL
       # @return [Object]
       attr_reader :options
 
+      # @return [Array<Symbol>, nil] `default_argument`s added, if any were added (otherwise, `nil`)
+      attr_reader :added_default_arguments
+
       # Called when the extension is mounted with `extension(name, options)`.
-      # The instance is frozen to avoid improper use of state during execution.
+      # The instance will be frozen to avoid improper use of state during execution.
       # @param field [GraphQL::Schema::Field] The field where this extension was mounted
       # @param options [Object] The second argument to `extension`, or `{}` if nothing was passed.
       def initialize(field:, options:)
         @field = field
         @options = options || {}
+        @added_default_arguments = nil
         apply
-        freeze
       end
 
+      class << self
+        # @return [Array(Array, Hash), nil] A list of default argument configs, or `nil` if there aren't any
+        def default_argument_configurations
+          args = superclass.respond_to?(:default_argument_configurations) ? superclass.default_argument_configurations : nil
+          if @own_default_argument_configurations
+            if args
+              args.concat(@own_default_argument_configurations)
+            else
+              args = @own_default_argument_configurations.dup
+            end
+          end
+          args
+        end
+
+        # @see Argument#initialize
+        # @see HasArguments#argument
+        def default_argument(*argument_args, **argument_kwargs)
+          configs = @own_default_argument_configurations ||= []
+          configs << [argument_args, argument_kwargs]
+        end
+
+        # If configured, these `extras` will be added to the field if they aren't already present,
+        # but removed by from `arguments` before the field's `resolve` is called.
+        # (The extras _will_ be present for other extensions, though.)
+        #
+        # @param new_extras [Array<Symbol>] If provided, assign extras used by this extension
+        # @return [Array<Symbol>] any extras assigned to this extension
+        def extras(new_extras = nil)
+          if new_extras
+            @own_extras = new_extras
+          end
+
+          inherited_extras = self.superclass.respond_to?(:extras) ? superclass.extras : nil
+          if @own_extras
+            if inherited_extras
+              inherited_extras + @own_extras
+            else
+              @own_extras
+            end
+          elsif inherited_extras
+            inherited_extras
+          else
+            NO_EXTRAS
+          end
+        end
+      end
+
+      NO_EXTRAS = [].freeze
+      private_constant :NO_EXTRAS
+
       # Called when this extension is attached to a field.
       # The field definition may be extended during this method.
       # @return [void]
       def apply
       end
 
+      # Called after the field's definition block has been executed.
+      # (Any arguments from the block are present on `field`)
+      # @return [void]
+      def after_define
+      end
+
+      # @api private
+      def after_define_apply
+        after_define
+        if (configs = self.class.default_argument_configurations)
+          existing_keywords = field.all_argument_definitions.map(&:keyword)
+          existing_keywords.uniq!
+          @added_default_arguments = []
+          configs.each do |config|
+            argument_args, argument_kwargs = config
+            arg_name = argument_args[0]
+            if !existing_keywords.include?(arg_name)
+              @added_default_arguments << arg_name
+              field.argument(*argument_args, **argument_kwargs)
+            end
+          end
+        end
+        if (extras = self.class.extras).any?
+          @added_extras = extras - field.extras
+          field.extras(@added_extras)
+        else
+          @added_extras = nil
+        end
+        freeze
+      end
+
+      # @api private
+      attr_reader :added_extras
+
       # Called before resolving {#field}. It should either:
       #
       # - `yield` values to continue execution; OR

data/lib/graphql/schema/input_object.rb

@@ -79,6 +79,21 @@ module GraphQL
         end
       end
 
+      def self.authorized?(obj, value, ctx)
+        # Authorize each argument (but this doesn't apply if `prepare` is implemented):
+        if value.is_a?(InputObject)
+          arguments(ctx).each do |_name, input_obj_arg|
+            input_obj_arg = input_obj_arg.type_class
+            if value.key?(input_obj_arg.keyword) &&
+              !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
+              return false
+            end
+          end
+        end
+        # It didn't early-return false:
+        true
+      end
+
       def unwrap_value(value)
         case value
         when Array
@@ -132,6 +147,8 @@ module GraphQL
           argument_defn
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::InputObjectType.new
           type_defn.name = graphql_name
@@ -140,7 +157,7 @@ module GraphQL
           type_defn.mutation = mutation
           type_defn.ast_node = ast_node
           all_argument_definitions.each do |arg|
-            type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+            type_defn.arguments[arg.graphql_definition(silence_deprecation_warning: true).name] = arg.graphql_definition(silence_deprecation_warning: true) # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           # Make a reference to a classic-style Arguments class
           self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)

data/lib/graphql/schema/interface.rb

@@ -100,6 +100,8 @@ module GraphQL
           end
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::InterfaceType.new
           type_defn.name = graphql_name
@@ -108,7 +110,7 @@ module GraphQL
           type_defn.type_membership_class = self.type_membership_class
           type_defn.ast_node = ast_node
           fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.graphql_definition
+            field_defn = field_inst.graphql_definition(silence_deprecation_warning: true)
             type_defn.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           type_defn.metadata[:type_class] = self

data/lib/graphql/schema/introspection_system.rb

@@ -107,7 +107,7 @@ module GraphQL
           dup_type_class(const)
         else
           # Use `.to_graphql` to get a freshly-made version, not shared between schemas
-          const.to_graphql
+          const.deprecated_to_graphql
         end
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared

data/lib/graphql/schema/list.rb

@@ -8,8 +8,10 @@ module GraphQL
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
-        @of_type.graphql_definition.to_list_type
+        @of_type.graphql_definition(silence_deprecation_warning: true).to_list_type
       end
 
       # @return [GraphQL::TypeKinds::LIST]

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

@@ -123,8 +123,13 @@ module GraphQL
         end
 
         module ToGraphQLExtension
-          def to_graphql
-            defn = super
+          def to_graphql(*args, **kwargs)
+
+            defn = if args.empty? && kwargs.empty?
+              super()
+            else
+              super
+            end
             accepts_definition_methods.each do |method_name|
               value = public_send(method_name)
               if !value.nil?

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

@@ -11,8 +11,24 @@ module GraphQL
         # A cached result of {.to_graphql}.
         # It's cached here so that user-overridden {.to_graphql} implementations
         # are also cached
-        def graphql_definition
-          @graphql_definition ||= to_graphql
+        def graphql_definition(silence_deprecation_warning: false)
+          @graphql_definition ||= begin
+            unless silence_deprecation_warning
+              message = "Legacy `.graphql_definition` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.graphql_definition` to use a class-based definition instead."
+              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
+              GraphQL::Deprecation.warn(message + caller_message)
+            end
+            deprecated_to_graphql
+          end
+        end
+
+        def deprecated_to_graphql
+          case method(:to_graphql).arity
+          when 0
+            to_graphql
+          else
+            to_graphql(silence_deprecation_warning: true)
+          end
         end
 
         # This is for a common interface with .define-based types
@@ -25,6 +41,17 @@ module GraphQL
           super
           @graphql_definition = nil
         end
+
+        module DeprecatedToGraphQL
+          def to_graphql(silence_deprecation_warning: false)
+            unless silence_deprecation_warning
+              message = "Legacy `.to_graphql` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.to_graphql` to use a class-based definition instead."
+              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
+              GraphQL::Deprecation.warn(message + caller_message)
+            end
+            super()
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/non_null.rb

@@ -8,8 +8,10 @@ module GraphQL
     class NonNull < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
-        @of_type.graphql_definition.to_non_null_type
+        @of_type.graphql_definition(silence_deprecation_warning: true).to_non_null_type
       end
 
        # @return [GraphQL::TypeKinds::NON_NULL]
@@ -51,6 +53,10 @@ module GraphQL
       end
 
       def coerce_input(value, ctx)
+        # `.validate_input` above is used for variables, but this method is used for arguments
+        if value.nil?
+          raise GraphQL::ExecutionError, "`null` is not a valid input for `#{to_type_signature}`, please provide a value for this argument."
+        end
         of_type.coerce_input(value, ctx)
       end
 

data/lib/graphql/schema/object.rb

@@ -122,6 +122,8 @@ module GraphQL
           all_fields
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         # @return [GraphQL::ObjectType]
         def to_graphql
           obj_type = GraphQL::ObjectType.new
@@ -132,7 +134,7 @@ module GraphQL
           obj_type.mutation = mutation
           obj_type.ast_node = ast_node
           fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.to_graphql
+            field_defn = field_inst.to_graphql(silence_deprecation_warning: true)
             obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
 

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -155,6 +155,14 @@ module GraphQL
           end
         end
       end
+
+      private
+
+      def authorize_arguments(args, values)
+        # remove the `input` wrapper to match values
+        input_args = args["input"].type.unwrap.arguments(context)
+        super(input_args, values)
+      end
     end
   end
 end

data/lib/graphql/schema/resolver.rb

@@ -145,19 +145,9 @@ module GraphQL
       # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
       # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
       def authorized?(**inputs)
-        self.class.arguments(context).each_value do |argument|
-          arg_keyword = argument.keyword
-          if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
-            arg_auth, err = argument.authorized?(self, arg_value, context)
-            if !arg_auth
-              return arg_auth, err
-            else
-              true
-            end
-          else
-            true
-          end
-        end
+        arg_owner = @field # || self.class
+        args = arg_owner.arguments(context)
+        authorize_arguments(args, inputs)
       end
 
       # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
@@ -172,6 +162,22 @@ module GraphQL
 
       private
 
+      def authorize_arguments(args, inputs)
+        args.each_value do |argument|
+          arg_keyword = argument.keyword
+          if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
+            arg_auth, err = argument.authorized?(self, arg_value, context)
+            if !arg_auth
+              return arg_auth, err
+            else
+              true
+            end
+          else
+            true
+          end
+        end
+      end
+
       def load_arguments(args)
         prepared_args = {}
         prepare_lazies = []

data/lib/graphql/schema/scalar.rb

@@ -14,6 +14,8 @@ module GraphQL
           val
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::ScalarType.new
           type_defn.name = graphql_name