graphql 1.9.17 → 1.11.7

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

@@ -7,11 +7,11 @@ module GraphQL
       module HasFields
         # Add a field to this object or interface with the given definition
         # @see {GraphQL::Schema::Field#initialize} for method signature
-        # @return [void]
+        # @return [GraphQL::Schema::Field]
         def field(*args, **kwargs, &block)
           field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
           add_field(field_defn)
-          nil
+          field_defn
         end
 
         # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
@@ -47,20 +47,22 @@ module GraphQL
         # A list of GraphQL-Ruby keywords.
         #
         # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method]
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :raw_value]
 
         # A list of field names that we should advise users to pick a different
         # resolve method name.
         #
         # @api private
-        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS)
+        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS + Object.instance_methods)
 
         # Register this field with the class, overriding a previous one if needed.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
-        def add_field(field_defn)
-          if CONFLICT_FIELD_NAMES.include?(field_defn.original_name) && field_defn.original_name == field_defn.resolver_method
-            warn "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.original_name}` and `def resolve_#{field_defn.original_name}`)"
+        def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
+          # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
+          # that shows that no override value was given manually.
+          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym
+            warn(conflict_field_name_warning(field_defn))
           end
           own_fields[field_defn.name] = field_defn
           nil
@@ -70,7 +72,7 @@ module GraphQL
         def field_class(new_field_class = nil)
           if new_field_class
             @field_class = new_field_class
-          elsif @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
@@ -80,9 +82,9 @@ module GraphQL
           end
         end
 
-        def global_id_field(field_name)
+        def global_id_field(field_name, **kwargs)
           id_resolver = GraphQL::Relay::GlobalIdResolve.new(type: self)
-          field field_name, "ID", null: false
+          field field_name, "ID", **kwargs, null: false
           define_method(field_name) do
             id_resolver.call(object, {}, context)
           end
@@ -92,6 +94,14 @@ module GraphQL
         def own_fields
           @own_fields ||= {}
         end
+
+        private
+
+        # @param [GraphQL::Schema::Field]
+        # @return [String] A warning to give when this field definition might conflict with a built-in method
+        def conflict_field_name_warning(field_defn)
+          "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`). Or use `method_conflict_warning: false` to suppress this warning."
+        end
       end
     end
   end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Set up a type-specific error to make debugging & bug tracker integration better
+      module HasUnresolvedTypeError
+        private
+        def add_unresolved_type_error(child_class)
+          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+        end
+      end
+    end
+  end
+end

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

@@ -6,12 +6,12 @@ module GraphQL
       module TypeSystemHelpers
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
-          GraphQL::Schema::NonNull.new(self)
+          @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
         end
 
         # @return [Schema::List] Make a list-type representation of this type
         def to_list_type
-          GraphQL::Schema::List.new(self)
+          @to_list_type ||= GraphQL::Schema::List.new(self)
         end
 
         # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module ValidatesInput
+        def valid_input?(val, ctx)
+          validate_input(val, ctx).valid?
+        end
+
+        def validate_input(val, ctx)
+          if val.nil?
+            GraphQL::Query::InputValidationResult.new
+          else
+            validate_non_null_input(val, ctx)
+          end
+        end
+
+        def valid_isolated_input?(v)
+          valid_input?(v, GraphQL::Query::NullContext)
+        end
+
+        def coerce_isolated_input(v)
+          coerce_input(v, GraphQL::Query::NullContext)
+        end
+
+        def coerce_isolated_result(v)
+          coerce_result(v, GraphQL::Query::NullContext)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -3,10 +3,13 @@ require 'graphql/schema/member/accepts_definition'
 require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
+require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_path'
+require 'graphql/schema/member/has_unresolved_type_error'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
+require 'graphql/schema/member/validates_input'
 require "graphql/relay/type_extensions"
 
 module GraphQL
@@ -20,10 +23,13 @@ module GraphQL
       extend CachedGraphQLDefinition
       extend GraphQL::Relay::TypeExtensions
       extend BaseDSLMethods
+      extend BaseDSLMethods::ConfigurationExtension
+      introspection(false)
       extend TypeSystemHelpers
       extend Scoped
       extend RelayShortcuts
       extend HasPath
+      extend HasAstNode
     end
   end
 end

data/lib/graphql/schema/mutation.rb

@@ -64,7 +64,7 @@ module GraphQL
 
       class << self
         # Override this method to handle legacy-style usages of `MyMutation.field`
-        def field(*args, &block)
+        def field(*args, **kwargs, &block)
           if args.empty?
             raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
           else
@@ -78,6 +78,10 @@ module GraphQL
 
         private
 
+        def conflict_field_name_warning(field_defn)
+          "#{self.graphql_name}'s `field :#{field_defn.name}` conflicts with a built-in method, use `hash_key:` or `method:` to pick a different resolve behavior for this field (for example, `hash_key: :#{field_defn.resolver_method}_value`, and modify the return hash). Or use `method_conflict_warning: false` to suppress this warning."
+        end
+
         # Override this to attach self as `mutation`
         def generate_payload_type
           payload_class = super

data/lib/graphql/schema/non_null.rb

@@ -6,6 +6,8 @@ module GraphQL
     # Wraps a {Schema::Member} when it is required.
     # @see {Schema::Member::TypeSystemHelpers#to_non_null_type}
     class NonNull < GraphQL::Schema::Wrapper
+      include Schema::Member::ValidatesInput
+
       def to_graphql
         @of_type.graphql_definition.to_non_null_type
       end
@@ -32,6 +34,34 @@ module GraphQL
       def inspect
         "#<#{self.class.name} @of_type=#{@of_type.inspect}>"
       end
+
+      def validate_input(value, ctx)
+        if value.nil?
+          result = GraphQL::Query::InputValidationResult.new
+          result.add_problem("Expected value to not be null")
+          result
+        else
+          of_type.validate_input(value, ctx)
+        end
+      end
+
+      # This is for introspection, where it's expected the name will be `null`
+      def graphql_name
+        nil
+      end
+
+      def coerce_input(value, ctx)
+        of_type.coerce_input(value, ctx)
+      end
+
+      def coerce_result(value, ctx)
+        of_type.coerce_result(value, ctx)
+      end
+
+      # This is for implementing introspection
+      def description
+        nil
+      end
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/query/null_context"
+
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
@@ -57,13 +59,9 @@ module GraphQL
                 else
                   nil
                 end
-              # rescue GraphQL::ExecutionError => err
-              #   err
               end
             end
           end
-        # rescue GraphQL::ExecutionError => err
-        #   err
         end
       end
 
@@ -73,34 +71,88 @@ module GraphQL
       end
 
       class << self
-        def implements(*new_interfaces)
+        # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
+        # It should help with debugging and bug tracker integrations.
+        def inherited(child_class)
+          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
+          super
+        end
+
+        def implements(*new_interfaces, **options)
+          new_memberships = []
           new_interfaces.each do |int|
             if int.is_a?(Module)
               unless int.include?(GraphQL::Schema::Interface)
                 raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
+              new_memberships << int.type_membership_class.new(int, self, **options)
+
               # Include the methods here,
               # `.fields` will use the inheritance chain
               # to find inherited fields
               include(int)
+            elsif int.is_a?(GraphQL::InterfaceType)
+              new_memberships << int.type_membership_class.new(int, self, **options)
+            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
+              if options.any?
+                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
+            else
+              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
             end
           end
-          own_interfaces.concat(new_interfaces)
+
+          # Remove any interfaces which are being replaced (late-bound types are updated in place this way)
+          own_interface_type_memberships.reject! { |old_i_m|
+            old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
+            old_name = Schema::Member::BuildType.to_type_name(old_int_type)
+
+            new_memberships.any? { |new_i_m|
+              new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
+              new_name = Schema::Member::BuildType.to_type_name(new_int_type)
+
+              new_name == old_name
+            }
+          }
+          own_interface_type_memberships.concat(new_memberships)
+        end
+
+        def own_interface_type_memberships
+          @own_interface_type_memberships ||= []
         end
 
-        def interfaces
-          own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
+        def interface_type_memberships
+          own_interface_type_memberships + (superclass.respond_to?(:interface_type_memberships) ? superclass.interface_type_memberships : [])
         end
 
-        def own_interfaces
-          @own_interfaces ||= []
+        # param context [Query::Context] If omitted, skip filtering.
+        def interfaces(context = GraphQL::Query::NullContext)
+          visible_interfaces = []
+          unfiltered = context == GraphQL::Query::NullContext
+          own_interface_type_memberships.each do |type_membership|
+            # During initialization, `type_memberships` can hold late-bound types
+            case type_membership
+            when String, Schema::LateBoundType
+              visible_interfaces << type_membership
+            when Schema::TypeMembership
+              if unfiltered || type_membership.visible?(context)
+                visible_interfaces << type_membership.abstract_type
+              end
+            else
+              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
+            end
+          end
+          visible_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces(context) : [])
         end
 
-        # Include legacy-style interfaces, too
+        # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
+        # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
         def fields
           all_fields = super
           interfaces.each do |int|
+            # Include legacy-style interfaces, too
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
               int.fields.each do |name, legacy_field|
@@ -117,9 +169,10 @@ module GraphQL
           obj_type = GraphQL::ObjectType.new
           obj_type.name = graphql_name
           obj_type.description = description
-          obj_type.interfaces = interfaces
+          obj_type.structural_interface_type_memberships = interface_type_memberships
           obj_type.introspection = introspection
           obj_type.mutation = mutation
+          obj_type.ast_node = ast_node
           fields.each do |field_name, field_inst|
             field_defn = field_inst.to_graphql
             obj_type.fields[field_defn.name] = field_defn

data/lib/graphql/schema/possible_types.rb

@@ -14,9 +14,10 @@ module GraphQL
     class PossibleTypes
       def initialize(schema)
         @object_types = schema.types.values.select { |type| type.kind.object? }
-
-        @interface_implementers = Hash.new do |hash, key|
-          hash[key] = @object_types.select { |type| type.interfaces.include?(key) }.sort_by(&:name)
+        @interface_implementers = Hash.new do |h1, ctx|
+          h1[ctx] = Hash.new do |h2, int_type|
+            h2[int_type] = @object_types.select { |type| type.interfaces(ctx).include?(int_type) }.sort_by(&:name)
+          end
         end
       end
 
@@ -27,13 +28,17 @@ module GraphQL
         when GraphQL::UnionType
           type_defn.possible_types(ctx)
         when GraphQL::InterfaceType
-          @interface_implementers[type_defn]
+          interface_implementers(ctx, type_defn)
         when GraphQL::BaseType
           [type_defn]
         else
           raise "Unexpected possible_types object: #{type_defn.inspect}"
         end
       end
+
+      def interface_implementers(ctx, type_defn)
+        @interface_implementers[ctx][type_defn]
+      end
     end
   end
 end

data/lib/graphql/schema/printer.rb

@@ -54,7 +54,6 @@ module GraphQL
         )
 
         @document = @document_from_schema.document
-
         @schema = schema
       end
 
@@ -95,20 +94,6 @@ module GraphQL
         print(node)
       end
 
-      def print_directive(directive)
-        if directive.name == "deprecated"
-          reason = directive.arguments.find { |arg| arg.name == "reason" }
-
-          if reason.value == GraphQL::Directive::DEFAULT_DEPRECATION_REASON
-            "@deprecated"
-          else
-            "@deprecated(reason: #{reason.value.to_s.inspect})"
-          end
-        else
-          super
-        end
-      end
-
       class IntrospectionPrinter < GraphQL::Language::Printer
         def print_schema_definition(schema)
           "schema {\n  query: Root\n}"

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -61,7 +61,7 @@ module GraphQL
         end
 
         return_value = if input_kwargs.any?
-          super(input_kwargs)
+          super(**input_kwargs)
         else
           super()
         end
@@ -105,7 +105,7 @@ module GraphQL
           sig = super
           # Arguments were added at the root, but they should be nested
           sig[:arguments].clear
-          sig[:arguments][:input] = { type: input_type, required: true }
+          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
           sig
         end
 
@@ -122,7 +122,9 @@ module GraphQL
             graphql_name("#{mutation_name}Input")
             description("Autogenerated input type of #{mutation_name}")
             mutation(mutation_class)
-            own_arguments.merge!(mutation_args)
+            mutation_args.each do |_name, arg|
+              add_argument(arg)
+            end
             argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
           end
         end

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -26,8 +26,10 @@ module GraphQL
         def field_class(new_class = nil)
           if new_class
             @field_class = new_class
+          elsif defined?(@field_class) && @field_class
+            @field_class
           else
-            @field_class || find_inherited_value(:field_class, GraphQL::Schema::Field)
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 
@@ -56,7 +58,8 @@ module GraphQL
             resolver_fields.each do |name, f|
               # Reattach the already-defined field here
               # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              add_field(f)
+              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+              add_field(f, method_conflict_warning: false)
             end
           end
         end

data/lib/graphql/schema/resolver.rb

@@ -40,6 +40,7 @@ module GraphQL
           @arguments_by_keyword[arg.keyword] = arg
         end
         @arguments_loads_as_type = self.class.arguments_loads_as_type
+        @prepared_arguments = nil
       end
 
       # @return [Object] The application object this field is being resolved on
@@ -51,6 +52,10 @@ module GraphQL
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      def arguments
+        @prepared_arguments || raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
+      end
+
       # This method is _actually_ called by the runtime,
       # it does some preparation and then eventually calls
       # the user-defined `#resolve` method.
@@ -74,9 +79,10 @@ module GraphQL
             # for that argument, or may return a lazy object
             load_arguments_val = load_arguments(args)
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
+              @prepared_arguments = loaded_args
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
-                authorized?(loaded_args)
+                authorized?(**loaded_args)
               else
                 authorized?
               end
@@ -135,20 +141,8 @@ module GraphQL
       def authorized?(**inputs)
         self.class.arguments.each_value do |argument|
           arg_keyword = argument.keyword
-          if inputs.key?(arg_keyword) && !(value = inputs[arg_keyword]).nil? && (value != argument.default_value)
-            loads_type = @arguments_loads_as_type[arg_keyword]
-            # If this argument resulted in an object being loaded,
-            # then authorize this loaded object with its own policy.
-            #
-            # But if this argument was "just" a plain argument, like
-            # a boolean, then authorize it based on the mutation.
-            authorization_value = if loads_type
-              value
-            else
-              self
-            end
-
-            arg_auth, err = argument.authorized?(authorization_value, context)
+          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
@@ -232,7 +226,7 @@ module GraphQL
         # or use it as a configuration method to assign a return type
         # instead of generating one.
         # TODO unify with {#null}
-        # @param new_type [Class, nil] If a type definition class is provided, it will be used as the return type of the field
+        # @param new_type [Class, Array<Class>, nil] If a type definition class is provided, it will be used as the return type of the field
         # @param null [true, false] Whether or not the field may return `nil`
         # @return [Class] The type which this field returns.
         def type(new_type = nil, null: nil)
@@ -262,6 +256,19 @@ module GraphQL
           @complexity || (superclass.respond_to?(:complexity) ? superclass.complexity : 1)
         end
 
+        def broadcastable(new_broadcastable)
+          @broadcastable = new_broadcastable
+        end
+
+        # @return [Boolean, nil]
+        def broadcastable?
+          if defined?(@broadcastable)
+            @broadcastable
+          else
+            (superclass.respond_to?(:broadcastable?) ? superclass.broadcastable? : nil)
+          end
+        end
+
         def field_options
           {
             type: type_expr,
@@ -273,6 +280,7 @@ module GraphQL
             null: null,
             complexity: complexity,
             extensions: extensions,
+            broadcastable: broadcastable?,
           }
         end
 
@@ -297,7 +305,7 @@ module GraphQL
               argument = @arguments_by_keyword[:#{arg_defn.keyword}]
               lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
               context.schema.after_lazy(values) do |values2|
-                GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value) })
+                GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value, context) })
               end
             end
             RUBY
@@ -306,7 +314,7 @@ module GraphQL
             def load_#{arg_defn.keyword}(value)
               argument = @arguments_by_keyword[:#{arg_defn.keyword}]
               lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
-              load_application_object(argument, lookup_as_type, value)
+              load_application_object(argument, lookup_as_type, value, context)
             end
             RUBY
           else

data/lib/graphql/schema/scalar.rb

@@ -3,11 +3,9 @@ module GraphQL
   class Schema
     class Scalar < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::ValidatesInput
 
       class << self
-        extend Forwardable
-        def_delegators :graphql_definition, :coerce_isolated_input, :coerce_isolated_result
-
         def coerce_input(val, ctx)
           val
         end
@@ -24,6 +22,7 @@ module GraphQL
           type_defn.coerce_input = method(:coerce_input)
           type_defn.metadata[:type_class] = self
           type_defn.default_scalar = default_scalar
+          type_defn.ast_node = ast_node
           type_defn
         end
 
@@ -37,6 +36,31 @@ module GraphQL
           end
           @default_scalar
         end
+
+        def default_scalar?
+          @default_scalar ||= false
+        end
+
+        def validate_non_null_input(value, ctx)
+          result = Query::InputValidationResult.new
+          coerced_result = begin
+            coerce_input(value, ctx)
+          rescue GraphQL::CoercionError => err
+            err
+          end
+
+          if coerced_result.nil?
+            str_value = if value == Float::INFINITY
+              ""
+            else
+              " #{GraphQL::Language.serialize(value)}"
+            end
+            result.add_problem("Could not coerce value#{str_value} to #{graphql_name}")
+          elsif coerced_result.is_a?(GraphQL::CoercionError)
+            result.add_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+          end
+          result
+        end
       end
     end
   end