graphql 2.0.31 → 2.5.18

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
@@ -23,13 +31,14 @@ module GraphQL
         @ruby_style_hash = ruby_kwargs
         @arguments = arguments
         # Apply prepares, not great to have it duplicated here.
-        self.class.arguments(context).each_value do |arg_defn|
+        arg_defns = context ? context.types.arguments(self.class) : self.class.arguments(context).each_value
+        arg_defns.each do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
           if @ruby_style_hash.key?(ruby_kwargs_key)
             # 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
@@ -44,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
+          new_h = {}
+          keys.each { |k| @ruby_style_hash.key?(k) && new_h[k] = @ruby_style_hash[k] }
+          new_h
         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?)
-          arguments(ctx).each do |_name, 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 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?
-        directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) }
+      def prepare
+        self
       end
 
       def unwrap_value(value)
@@ -119,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?
@@ -131,12 +151,9 @@ module GraphQL
             end
           end
           # Add a method access
-          method_name = argument_defn.keyword
-          class_eval <<-RUBY, __FILE__, __LINE__
-            def #{method_name}
-              self[#{method_name.inspect}]
-            end
-          RUBY
+          suppress_redefinition_warning do
+            define_accessor_method(argument_defn.keyword)
+          end
           argument_defn
         end
 
@@ -145,10 +162,10 @@ module GraphQL
         end
 
         # @api private
-        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
+        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object."
 
         def validate_non_null_input(input, ctx, max_errors: nil)
-          warden = ctx.warden
+          types = ctx.types
 
           if input.is_a?(Array)
             return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
@@ -159,30 +176,37 @@ module GraphQL
             return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
-          # Inject missing required arguments
-          missing_required_inputs = self.arguments(ctx).reduce({}) do |m, (argument_name, argument)|
-            if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
-              m[argument_name] = nil
-            end
-
-            m
-          end
 
           result = nil
-          [input, missing_required_inputs].each do |args_to_validate|
-            args_to_validate.each do |argument_name, value|
-              argument = warden.get_argument(self, argument_name)
-              # Items in the input that are unexpected
-              if argument.nil?
-                result ||= Query::InputValidationResult.new
-                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              else
-                # Items in the input that are expected, but have invalid values
-                argument_result = argument.type.validate_input(value, ctx)
+
+
+          input.each do |argument_name, value|
+            argument = types.argument(self, argument_name)
+            if argument.nil? && ctx.is_a?(Query::NullContext) && argument_name.is_a?(Symbol)
+              # Validating definition directive arguments which come in as Symbols
+              argument = types.arguments(self).find { |arg| arg.keyword == argument_name }
+            end
+            # Items in the input that are unexpected
+            if argument.nil?
+              result ||= Query::InputValidationResult.new
+              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+            else
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              if !argument_result.valid?
                 result ||= Query::InputValidationResult.new
-                if !argument_result.valid?
-                  result.merge_result!(argument_name, argument_result)
-                end
+                result.merge_result!(argument_name, argument_result)
+              end
+            end
+          end
+
+          # Check for missing non-null arguments
+          ctx.types.arguments(self).each do |argument|
+            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value?
+              result ||= Query::InputValidationResult.new
+              argument_result = argument.type.validate_input(nil, ctx)
+              if !argument_result.valid?
+                result.merge_result!(argument.graphql_name, argument_result)
               end
             end
           end
@@ -215,8 +239,7 @@ module GraphQL
             if resolved_arguments.is_a?(GraphQL::Error)
               raise resolved_arguments
             else
-              input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
-              input_obj_instance.prepare
+              self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
             end
           end
         end
@@ -242,6 +265,41 @@ 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
+        def suppress_redefinition_warning
+          verbose = $VERBOSE
+          $VERBOSE = nil
+          yield
+        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
 
@@ -20,7 +21,16 @@ module GraphQL
         # - Added as class methods to this interface
         # - Added as class methods to all child interfaces
         def definition_methods(&block)
-          self::DefinitionMethods.module_eval(&block)
+          # Use an instance variable to tell whether it's been included previously or not;
+          # You can't use constant detection because constants are brought into scope
+          # by `include`, which has already happened at this point.
+          if !defined?(@_definition_methods)
+            defn_methods_module = Module.new
+            @_definition_methods = defn_methods_module
+            const_set(:DefinitionMethods, defn_methods_module)
+            extend(self::DefinitionMethods)
+          end
+          self::DefinitionMethods.module_exec(&block)
         end
 
         # @see {Schema::Warden} hides interfaces without visible implementations
@@ -47,22 +57,14 @@ module GraphQL
 
             child_class.type_membership_class(self.type_membership_class)
             child_class.ancestors.reverse_each do |ancestor|
-              if ancestor.const_defined?(:DefinitionMethods)
+              if ancestor.const_defined?(:DefinitionMethods) && ancestor != child_class
                 child_class.extend(ancestor::DefinitionMethods)
               end
             end
 
-            # Use an instance variable to tell whether it's been included previously or not;
-            # You can't use constant detection because constants are brought into scope
-            # by `include`, which has already happened at this point.
-            if !child_class.instance_variable_defined?(:@_definition_methods)
-              defn_methods_module = Module.new
-              child_class.instance_variable_set(:@_definition_methods, defn_methods_module)
-              child_class.const_set(:DefinitionMethods, defn_methods_module)
-              child_class.extend(child_class::DefinitionMethods)
-            end
             child_class.introspection(introspection)
             child_class.description(description)
+            child_class.comment(nil)
             # If interfaces are mixed into each other, only define this class once
             if !child_class.const_defined?(:UnresolvedTypeError, false)
               add_unresolved_type_error(child_class)
@@ -82,13 +84,29 @@ module GraphQL
           super
         end
 
+        # Register other Interface or Object types as implementers of this Interface.
+        #
+        # When those Interfaces or Objects aren't used as the return values of fields,
+        # they may have to be registered using this method so that GraphQL-Ruby can find them.
+        # @param types [Class, Module]
+        # @return [Array<Module, Class>] Implementers of this interface, if they're registered
         def orphan_types(*types)
-          if types.any?
-            @orphan_types = types
+          if !types.empty?
+            @orphan_types ||= []
+            @orphan_types.concat(types)
           else
-            all_orphan_types = @orphan_types || []
-            all_orphan_types += super if defined?(super)
-            all_orphan_types.uniq
+            if defined?(@orphan_types)
+              all_orphan_types = @orphan_types.dup
+              if defined?(super)
+                all_orphan_types += super
+                all_orphan_types.uniq!
+              end
+              all_orphan_types
+            elsif defined?(super)
+              super
+            else
+              EmptyObjects::EMPTY_ARRAY
+            end
           end
         end
 

data/lib/graphql/schema/introspection_system.rb

@@ -25,10 +25,10 @@ module GraphQL
           load_constant(:DirectiveLocationEnum)
         ]
         @types = {}
-        @possible_types = {}
+        @possible_types = {}.compare_by_identity
         type_defns.each do |t|
           @types[t.graphql_name] = t
-          @possible_types[t.graphql_name] = [t]
+          @possible_types[t] = [t]
         end
         @entry_point_fields =
           if schema.disable_introspection_entry_points?
@@ -39,7 +39,9 @@ module GraphQL
             entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point?
             entry_point_fields
           end
+        @entry_point_fields.each { |k, v| v.dynamic_introspection = true }
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+        @dynamic_fields.each { |k, v| v.dynamic_introspection = true }
       end
 
       def entry_points
@@ -67,7 +69,7 @@ module GraphQL
       def resolve_late_bindings
         @types.each do |name, t|
           if t.kind.fields?
-            t.fields.each do |_name, field_defn|
+            t.all_field_definitions.each do |field_defn|
               field_defn.type = resolve_late_binding(field_defn.type)
             end
           end
@@ -88,7 +90,8 @@ module GraphQL
       def resolve_late_binding(late_bound_type)
         case late_bound_type
         when GraphQL::Schema::LateBoundType
-          @schema.get_type(late_bound_type.name)
+          type_name = late_bound_type.name
+          @types[type_name] || @schema.get_type(type_name)
         when GraphQL::Schema::List
           resolve_late_binding(late_bound_type.of_type).to_list_type
         when GraphQL::Schema::NonNull
@@ -111,19 +114,7 @@ module GraphQL
 
       def get_fields_from_class(class_sym:)
         object_type_defn = load_constant(class_sym)
-
-        if object_type_defn.is_a?(Module)
-          object_type_defn.fields
-        else
-          extracted_field_defns = {}
-          object_class = object_type_defn.metadata[:type_class]
-          object_type_defn.all_fields.each do |field_defn|
-            inner_resolve = field_defn.resolve_proc
-            resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
-            extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
-          end
-          extracted_field_defns
-        end
+        object_type_defn.fields
       end
 
       # This is probably not 100% robust -- but it has to be good enough to avoid modifying the built-in introspection types

data/lib/graphql/schema/late_bound_type.rb

@@ -25,6 +25,10 @@ module GraphQL
         @to_list_type ||= GraphQL::Schema::List.new(self)
       end
 
+      def to_type_signature
+        name
+      end
+
       def inspect
         "#<LateBoundType @name=#{name}>"
       end

data/lib/graphql/schema/list.rb

@@ -4,7 +4,7 @@ module GraphQL
   class Schema
     # Represents a list type in the schema.
     # Wraps a {Schema::Member} as a list type.
-    # @see {Schema::Member::TypeSystemHelpers#to_list_type}
+    # @see Schema::Member::TypeSystemHelpers#to_list_type Create a list type from another GraphQL type
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
@@ -52,7 +52,7 @@ module GraphQL
           unless item_result.valid?
             if max_errors
               if max_errors == 0
-                add_max_errros_reached_message(result)
+                add_max_errors_reached_message(result)
                 break
               end
 
@@ -76,7 +76,7 @@ module GraphQL
         end
       end
 
-      def add_max_errros_reached_message(result)
+      def add_max_errors_reached_message(result)
         message = "Too many errors processing list variable, max validation error limit reached. Execution aborted"
         item_result = GraphQL::Query::InputValidationResult.from_problem(message)
         result.merge_result!(nil, item_result)

data/lib/graphql/schema/loader.rb

@@ -32,7 +32,8 @@ module GraphQL
         end
 
         Class.new(GraphQL::Schema) do
-          orphan_types(types.values)
+          add_type_and_traverse(types.values, root: false)
+          orphan_types(types.values.select { |t| t.kind.object? })
           directives(directives)
           description(schema["description"])
 
@@ -176,7 +177,6 @@ module GraphQL
             while (of_type = unwrapped_field_hash["ofType"])
               unwrapped_field_hash = of_type
             end
-            type_name = unwrapped_field_hash["name"]
 
             type_defn.field(
               field_hash["name"],
@@ -186,9 +186,8 @@ module GraphQL
               null: true,
               camelize: false,
               connection_extension: nil,
-              connection: type_name.end_with?("Connection"),
             ) 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/base_dsl_methods.rb

@@ -50,12 +50,27 @@ module GraphQL
           end
         end
 
+        # Call this method to provide a new comment; OR
+        # call it without an argument to get the comment
+        # @param new_comment [String]
+        # @return [String, nil]
+        def comment(new_comment = NOT_CONFIGURED)
+          if !NOT_CONFIGURED.equal?(new_comment)
+            @comment = new_comment
+          elsif defined?(@comment)
+            @comment
+          else
+            nil
+          end
+        end
+
         # This pushes some configurations _down_ the inheritance tree,
         # in order to prevent repetitive lookups at runtime.
         module ConfigurationExtension
           def inherited(child_class)
             child_class.introspection(introspection)
             child_class.description(description)
+            child_class.comment(nil)
             child_class.default_graphql_name = nil
 
             if defined?(@graphql_name) && @graphql_name && (self.name.nil? || graphql_name != default_graphql_name)
@@ -102,7 +117,8 @@ module GraphQL
         def default_graphql_name
           @default_graphql_name ||= begin
             raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
-            -name.split("::").last.sub(/Type\Z/, "")
+            g_name = -name.split("::").last
+            g_name.end_with?("Type") ? g_name.sub(/Type\Z/, "") : g_name
           end
         end