graphql 2.4.3 → 2.5.2

data/lib/graphql/schema/field.rb

@@ -41,10 +41,24 @@ module GraphQL
         end
       end
 
+      # @return [String, nil]
+      def deprecation_reason
+        super || @resolver_class&.deprecation_reason
+      end
+
       def directives
-        if @resolver_class && (r_dirs = @resolver_class.directives).any?
-          if (own_dirs = super).any?
-            own_dirs + r_dirs
+        if @resolver_class && !(r_dirs = @resolver_class.directives).empty?
+          if !(own_dirs = super).empty?
+            new_dirs = own_dirs.dup
+            r_dirs.each do |r_dir|
+              if r_dir.class.repeatable? ||
+                ( (r_dir_name = r_dir.graphql_name) &&
+                  (!new_dirs.any? { |d| d.graphql_name == r_dir_name })
+                )
+                new_dirs << r_dir
+              end
+            end
+            new_dirs
           else
             r_dirs
           end
@@ -81,7 +95,7 @@ module GraphQL
       end
 
       def inspect
-        "#<#{self.class} #{path}#{all_argument_definitions.any? ? "(...)" : ""}: #{type.to_type_signature}>"
+        "#<#{self.class} #{path}#{!all_argument_definitions.empty? ? "(...)" : ""}: #{type.to_type_signature}>"
       end
 
       alias :mutation :resolver
@@ -255,7 +269,7 @@ module GraphQL
 
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-
+        NameValidator.validate!(@name)
         @description = description
         @comment = comment
         @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary
@@ -335,15 +349,15 @@ module GraphQL
         @call_after_define = false
         set_pagination_extensions(connection_extension: connection_extension)
         # Do this last so we have as much context as possible when initializing them:
-        if extensions.any?
+        if !extensions.empty?
           self.extensions(extensions)
         end
 
-        if resolver_class && resolver_class.extensions.any?
+        if resolver_class && !resolver_class.extensions.empty?
           self.extensions(resolver_class.extensions)
         end
 
-        if directives.any?
+        if !directives.empty?
           directives.each do |(dir_class, options)|
             self.directive(dir_class, **options)
           end
@@ -369,7 +383,7 @@ module GraphQL
           if @definition_block.arity == 1
             @definition_block.call(self)
           else
-            instance_eval(&@definition_block)
+            instance_exec(self, &@definition_block)
           end
           self.extensions.each(&:after_define_apply)
           @call_after_define = true
@@ -482,7 +496,7 @@ module GraphQL
         if new_extras.nil?
           # Read the value
           field_extras = @extras
-          if @resolver_class && @resolver_class.extras.any?
+          if @resolver_class && !@resolver_class.extras.empty?
             field_extras + @resolver_class.extras
           else
             field_extras
@@ -732,7 +746,7 @@ module GraphQL
                 method_to_call = resolver_method
                 method_receiver = obj
                 # Call the method with kwargs, if there are any
-                if ruby_kwargs.any?
+                if !ruby_kwargs.empty?
                   obj.public_send(resolver_method, **ruby_kwargs)
                 else
                   obj.public_send(resolver_method)
@@ -752,7 +766,7 @@ module GraphQL
               elsif inner_object.respond_to?(@method_sym)
                 method_to_call = @method_sym
                 method_receiver = obj.object
-                if ruby_kwargs.any?
+                if !ruby_kwargs.empty?
                   inner_object.public_send(@method_sym, **ruby_kwargs)
                 else
                   inner_object.public_send(@method_sym)
@@ -839,7 +853,7 @@ module GraphQL
           unsatisfied_ruby_kwargs.clear
         end
 
-        if unsatisfied_ruby_kwargs.any? || unsatisfied_method_params.any?
+        if !unsatisfied_ruby_kwargs.empty? || !unsatisfied_method_params.empty?
           raise FieldImplementationFailed.new, <<-ERR
 Failed to call `#{method_name.inspect}` on #{receiver.inspect} because the Ruby method params were incompatible with the GraphQL arguments:
 

data/lib/graphql/schema/field_extension.rb

@@ -104,7 +104,7 @@ module GraphQL
             end
           end
         end
-        if (extras = self.class.extras).any?
+        if !(extras = self.class.extras).empty?
           @added_extras = extras - field.extras
           field.extras(@added_extras)
         else

data/lib/graphql/schema/has_single_input_argument.rb

@@ -32,7 +32,7 @@ module GraphQL
           input_kwargs = {}
         end
 
-        if input_kwargs.any?
+        if !input_kwargs.empty?
           super(**input_kwargs)
         else
           super()
@@ -136,6 +136,8 @@ module GraphQL
                 super || "Autogenerated input type of #{self.mutation.graphql_name}"
               end
             end
+            # For compatibility, in case no arguments are defined:
+            has_no_arguments(true)
             mutation(mutation_class)
             # these might be inherited:
             mutation_args.each do |arg|

data/lib/graphql/schema/input_object.rb

@@ -10,6 +10,14 @@ module GraphQL
 
       include GraphQL::Dig
 
+      # Raised when an InputObject doesn't have any arguments defined and hasn't explicitly opted out of this requirement
+      class ArgumentsAreRequiredError < GraphQL::Error
+        def initialize(input_object_type)
+          message = "Input Object types must have arguments, but #{input_object_type.graphql_name} doesn't have any. Define an argument for this type, remove it from your schema, or add `has_no_arguments(true)` to its definition."
+          super(message)
+        end
+      end
+
       # @return [GraphQL::Query::Context] The context for this query
       attr_reader :context
       # @return [GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
@@ -30,7 +38,7 @@ module GraphQL
             # Weirdly, procs are applied during coercion, but not methods.
             # Probably because these methods require a `self`.
             if arg_defn.prepare.is_a?(Symbol) || context.nil?
-              prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key], context: context)
               overwrite_argument(ruby_kwargs_key, prepared_value)
             end
           end
@@ -45,42 +53,18 @@ module GraphQL
         to_h
       end
 
-      def prepare
-        if @context
-          object = @context[:current_object]
-          # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
-          Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
-          self
+      def deconstruct_keys(keys = nil)
+        if keys.nil?
+          @ruby_style_hash
         else
-          self
-        end
-      end
-
-      def self.authorized?(obj, value, ctx)
-        # Authorize each argument (but this doesn't apply if `prepare` is implemented):
-        if value.respond_to?(:key?)
-          ctx.types.arguments(self).each do |input_obj_arg|
-            if value.key?(input_obj_arg.keyword) &&
-              !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
-              return false
-            end
-          end
+          new_h = {}
+          keys.each { |k| @ruby_style_hash.key?(k) && new_h[k] = @ruby_style_hash[k] }
+          new_h
         end
-        # It didn't early-return false:
-        true
       end
 
-      def self.one_of
-        if !one_of?
-          if all_argument_definitions.any? { |arg| arg.type.non_null? }
-            raise ArgumentError, "`one_of` may not be used with required arguments -- add `required: false` to argument definitions to use `one_of`"
-          end
-          directive(GraphQL::Schema::Directive::OneOf)
-        end
-      end
-
-      def self.one_of?
-        false # Re-defined when `OneOf` is added
+      def prepare
+        self
       end
 
       def unwrap_value(value)
@@ -120,7 +104,42 @@ module GraphQL
         @ruby_style_hash.dup
       end
 
+      # @api private
+      def validate_for(context)
+        object = context[:current_object]
+        # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+        Schema::Validator.validate!(self.class.validators, object, context, @ruby_style_hash, as: self.class)
+        nil
+      end
+
       class << self
+        def authorized?(obj, value, ctx)
+          # Authorize each argument (but this doesn't apply if `prepare` is implemented):
+          if value.respond_to?(:key?)
+            ctx.types.arguments(self).each do |input_obj_arg|
+              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 one_of
+          if !one_of?
+            if all_argument_definitions.any? { |arg| arg.type.non_null? }
+              raise ArgumentError, "`one_of` may not be used with required arguments -- add `required: false` to argument definitions to use `one_of`"
+            end
+            directive(GraphQL::Schema::Directive::OneOf)
+          end
+        end
+
+        def one_of?
+          false # Re-defined when `OneOf` is added
+        end
+
         def argument(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
           if one_of?
@@ -132,14 +151,8 @@ module GraphQL
             end
           end
           # Add a method access
-          method_name = argument_defn.keyword
           suppress_redefinition_warning do
-            class_eval <<-RUBY, __FILE__, __LINE__
-              def #{method_name}
-                self[#{method_name.inspect}]
-              end
-              alias_method :#{method_name}, :#{method_name}
-            RUBY
+            define_accessor_method(argument_defn.keyword)
           end
           argument_defn
         end
@@ -246,6 +259,25 @@ module GraphQL
           result
         end
 
+        # @param new_has_no_arguments [Boolean] Call with `true` to make this InputObject type ignore the requirement to have any defined arguments.
+        # @return [void]
+        def has_no_arguments(new_has_no_arguments)
+          @has_no_arguments = new_has_no_arguments
+          nil
+        end
+
+        # @return [Boolean] `true` if `has_no_arguments(true)` was configued
+        def has_no_arguments?
+          @has_no_arguments
+        end
+
+        def arguments(context = GraphQL::Query::NullContext.instance, require_defined_arguments = true)
+          if require_defined_arguments && !has_no_arguments? && !any_arguments?
+            warn(GraphQL::Schema::InputObject::ArgumentsAreRequiredError.new(self).message + "\n\nThis will raise an error in a future GraphQL-Ruby version.")
+          end
+          super(context, false)
+        end
+
         private
 
         # Suppress redefinition warning for objectId arguments
@@ -256,6 +288,11 @@ module GraphQL
         ensure
           $VERBOSE = verbose
         end
+
+        def define_accessor_method(method_name)
+          define_method(method_name) { self[method_name] }
+          alias_method(method_name, method_name)
+        end
       end
 
       private

data/lib/graphql/schema/interface.rb

@@ -13,6 +13,7 @@ module GraphQL
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
         include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDataloader
         include GraphQL::Schema::Member::HasDirectives
         include GraphQL::Schema::Member::HasInterfaces
 
@@ -29,7 +30,7 @@ module GraphQL
             const_set(:DefinitionMethods, defn_methods_module)
             extend(self::DefinitionMethods)
           end
-          self::DefinitionMethods.module_eval(&block)
+          self::DefinitionMethods.module_exec(&block)
         end
 
         # @see {Schema::Warden} hides interfaces without visible implementations
@@ -90,7 +91,7 @@ module GraphQL
         # @param types [Class, Module]
         # @return [Array<Module, Class>] Implementers of this interface, if they're registered
         def orphan_types(*types)
-          if types.any?
+          if !types.empty?
             @orphan_types ||= []
             @orphan_types.concat(types)
           else

data/lib/graphql/schema/loader.rb

@@ -187,7 +187,7 @@ module GraphQL
               camelize: false,
               connection_extension: nil,
             ) do
-              if field_hash["args"].any?
+              if !field_hash["args"].empty?
                 loader.build_arguments(self, field_hash["args"], type_resolver)
               end
             end

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

@@ -76,8 +76,8 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
-        def arguments(context = GraphQL::Query::NullContext.instance)
-          if own_arguments.any?
+        def arguments(context = GraphQL::Query::NullContext.instance, _require_defined_arguments = nil)
+          if !own_arguments.empty?
             own_arguments_that_apply = {}
             own_arguments.each do |name, args_entry|
               if (visible_defn = Warden.visible_entry?(:visible_argument?, args_entry, context))
@@ -90,7 +90,7 @@ module GraphQL
         end
 
         def any_arguments?
-          own_arguments.any?
+          !own_arguments.empty?
         end
 
         module ClassConfigured
@@ -100,12 +100,12 @@ module GraphQL
           end
 
           module InheritedArguments
-            def arguments(context = GraphQL::Query::NullContext.instance)
-              own_arguments = super
-              inherited_arguments = superclass.arguments(context)
+            def arguments(context = GraphQL::Query::NullContext.instance, require_defined_arguments = true)
+              own_arguments = super(context, require_defined_arguments)
+              inherited_arguments = superclass.arguments(context, false)
 
-              if own_arguments.any?
-                if inherited_arguments.any?
+              if !own_arguments.empty?
+                if !inherited_arguments.empty?
                   # Local definitions override inherited ones
                   inherited_arguments.merge(own_arguments)
                 else
@@ -149,12 +149,12 @@ module GraphQL
         end
 
         module FieldConfigured
-          def arguments(context = GraphQL::Query::NullContext.instance)
+          def arguments(context = GraphQL::Query::NullContext.instance, _require_defined_arguments = nil)
             own_arguments = super
             if @resolver_class
               inherited_arguments = @resolver_class.field_arguments(context)
-              if own_arguments.any?
-                if inherited_arguments.any?
+              if !own_arguments.empty?
+                if !inherited_arguments.empty?
                   inherited_arguments.merge(own_arguments)
                 else
                   own_arguments
@@ -198,7 +198,7 @@ module GraphQL
         end
 
         def all_argument_definitions
-          if own_arguments.any?
+          if !own_arguments.empty?
             all_defns = own_arguments.values
             all_defns.flatten!
             all_defns
@@ -359,7 +359,8 @@ module GraphQL
               if application_object.nil?
                 nil
               else
-                maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
+                arg_loads_type = argument.loads
+                maybe_lazy_resolve_type = context.schema.resolve_type(arg_loads_type, application_object, context)
                 context.query.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
@@ -368,10 +369,17 @@ module GraphQL
                     # application_object is already assigned
                   end
 
-                  if !(
-                      context.types.possible_types(argument.loads).include?(application_object_type) ||
-                      context.types.loadable?(argument.loads, context)
-                    )
+                  passes_possible_types_check = if context.types.loadable?(arg_loads_type, context)
+                    if arg_loads_type.kind.union?
+                      # This union is used in `loads:` but not otherwise visible to this query
+                      context.types.loadable_possible_types(arg_loads_type, context).include?(application_object_type)
+                    else
+                      true
+                    end
+                  else
+                    context.types.possible_types(arg_loads_type).include?(application_object_type)
+                  end
+                  if !passes_possible_types_check
                     err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
                     application_object = load_application_object_failed(err)
                   end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDataloader
+        # @return [GraphQL::Dataloader] The dataloader for the currently-running query
+        def dataloader
+          context.dataloader
+        end
+
+        # A shortcut method for loading a key from a source.
+        # Identical to `dataloader.with(source_class, *source_args).load(load_key)`
+        # @param source_class [Class<GraphQL::Dataloader::Source>]
+        # @param source_args [Array<Object>] Any extra parameters defined in `source_class`'s `initialize` method
+        # @param load_key [Object] The key to look up using `def fetch`
+        def dataload(source_class, *source_args, load_key)
+          dataloader.with(source_class, *source_args).load(load_key)
+        end
+
+        # Find an object with ActiveRecord via {Dataloader::ActiveRecordSource}.
+        # @param model [Class<ActiveRecord::Base>]
+        # @param find_by_value [Object] Usually an `id`, might be another value if `find_by:` is also provided
+        # @param find_by [Symbol, String] A column name to look the record up by. (Defaults to the model's primary key.)
+        # @return [ActiveRecord::Base, nil]
+        # @example Finding a record by ID
+        #   dataload_record(Post, 5) # Like `Post.find(5)`, but dataloaded
+        # @example Finding a record by another attribute
+        #   dataload_record(User, "matz", find_by: :handle) # Like `User.find_by(handle: "matz")`, but dataloaded
+        def dataload_record(model, find_by_value, find_by: nil)
+          source = if find_by
+            dataloader.with(Dataloader::ActiveRecordSource, model, find_by: find_by)
+          else
+            dataloader.with(Dataloader::ActiveRecordSource, model)
+          end
+
+          source.load(find_by_value)
+        end
+
+        # Look up an associated record using a Rails association.
+        # @param association_name [Symbol] A `belongs_to` or `has_one` association. (If a `has_many` association is named here, it will be selected without pagination.)
+        # @param record [ActiveRecord::Base] The object that the association belongs to.
+        # @param scope [ActiveRecord::Relation] A scope to look up the associated record in
+        # @return [ActiveRecord::Base, nil] The associated record, if there is one
+        # @example Looking up a belongs_to on the current object
+        #    dataload_association(:parent) # Equivalent to `object.parent`, but dataloaded
+        # @example Looking up an associated record on some other object
+        #    dataload_association(:post, comment) # Equivalent to `comment.post`, but dataloaded
+        def dataload_association(record = object, association_name, scope: nil)
+          source = if scope
+            dataloader.with(Dataloader::ActiveRecordAssociationSource, association_name, scope)
+          else
+            dataloader.with(Dataloader::ActiveRecordAssociationSource, association_name)
+          end
+          source.load(record)
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,21 @@ module GraphQL
             directive(GraphQL::Schema::Directive::Deprecated, reason: text)
           end
         end
+
+        def self.extended(child_class)
+          super
+          child_class.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def deprecation_reason(new_reason = NOT_CONFIGURED)
+            if NOT_CONFIGURED.equal?(new_reason)
+              super()
+            else
+              self.deprecation_reason = new_reason
+            end
+          end
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module GraphQL
       module HasDirectives
         def self.extended(child_cls)
           super
-          child_cls.module_eval { self.own_directives = nil }
+          child_cls.module_exec { self.own_directives = nil }
         end
 
         def inherited(child_cls)
@@ -55,14 +55,14 @@ module GraphQL
               else
                 GraphQL::EmptyObjects::EMPTY_ARRAY
               end
-              if inherited_directives.any? && directives
+              if !inherited_directives.empty? && directives
                 dirs = []
                 merge_directives(dirs, inherited_directives)
                 merge_directives(dirs, directives)
                 dirs
               elsif directives
                 directives
-              elsif inherited_directives.any?
+              elsif !inherited_directives.empty?
                 inherited_directives
               else
                 GraphQL::EmptyObjects::EMPTY_ARRAY
@@ -71,7 +71,7 @@ module GraphQL
               dirs = nil
               schema_member.ancestors.reverse_each do |ancestor|
                 if ancestor.respond_to?(:own_directives) &&
-                    (anc_dirs = ancestor.own_directives).any?
+                    !(anc_dirs = ancestor.own_directives).empty?
                   dirs ||= []
                   merge_directives(dirs, anc_dirs)
                 end

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

@@ -79,6 +79,18 @@ module GraphQL
           end
         end
 
+        # @param new_has_no_fields [Boolean] Call with `true` to make this Object type ignore the requirement to have any defined fields.
+        # @return [void]
+        def has_no_fields(new_has_no_fields)
+          @has_no_fields = new_has_no_fields
+          nil
+        end
+
+        # @return [Boolean] `true` if `has_no_fields(true)` was configued
+        def has_no_fields?
+          @has_no_fields
+        end
+
         # @return [Hash<String => GraphQL::Schema::Field, Array<GraphQL::Schema::Field>>] Fields defined on this class _specifically_, not parent classes
         def own_fields
           @own_fields ||= {}
@@ -155,9 +167,11 @@ module GraphQL
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields
             visible_fields = {}
+            had_any_fields_at_all = false
             for ancestor in ancestors
               if ancestor.respond_to?(:own_fields) && visible_interface_implementation?(ancestor, context, warden)
                 ancestor.own_fields.each do |field_name, fields_entry|
+                  had_any_fields_at_all = true
                   # Choose the most local definition that passes `.visible?` --
                   # stop checking for fields by name once one has been found.
                   if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
@@ -166,6 +180,9 @@ module GraphQL
                 end
               end
             end
+            if !had_any_fields_at_all && !has_no_fields?
+              warn(GraphQL::Schema::Object::FieldsAreRequiredError.new(self).message + "\n\nThis will raise an error in a future GraphQL-Ruby version.")
+            end
             visible_fields
           end
         end
@@ -185,9 +202,10 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @own_fields ||= nil
             @field_class ||= nil
+            @has_no_fields ||= false
           end
         end
 

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

@@ -24,7 +24,7 @@ module GraphQL
                 implements(next_interface)
               end
             elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
-              if options.any?
+              if !options.empty?
                 raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
               end
               new_memberships << int
@@ -73,13 +73,13 @@ module GraphQL
             def interfaces(context = GraphQL::Query::NullContext.instance)
               visible_interfaces = super
               inherited_interfaces = superclass.interfaces(context)
-              if visible_interfaces.any?
-                if inherited_interfaces.any?
+              if !visible_interfaces.empty?
+                if !inherited_interfaces.empty?
                   visible_interfaces.concat(inherited_interfaces)
                   visible_interfaces.uniq!
                 end
                 visible_interfaces
-              elsif inherited_interfaces.any?
+              elsif !inherited_interfaces.empty?
                 inherited_interfaces
               else
                 EmptyObjects::EMPTY_ARRAY
@@ -133,7 +133,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @own_interface_type_memberships ||= nil
           end
         end

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

@@ -32,7 +32,7 @@ module GraphQL
 
             def validators
               inherited_validators = superclass.validators
-              if inherited_validators.any?
+              if !inherited_validators.empty?
                 if @own_validators.nil?
                   inherited_validators
                 else

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

@@ -30,7 +30,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @reauthorize_scoped_objects = nil
           end
         end

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

@@ -42,7 +42,7 @@ module GraphQL
         private
 
         def inherited(subclass)
-          subclass.class_eval do
+          subclass.class_exec do
             @to_non_null_type ||= nil
             @to_list_type ||= nil
           end