graphql 1.9.17 → 1.10.0

data/lib/graphql/schema/introspection_system.rb

@@ -2,44 +2,46 @@
 module GraphQL
   class Schema
     class IntrospectionSystem
-      attr_reader :schema_type, :type_type, :typename_field
+      attr_reader :types, :possible_types
 
       def initialize(schema)
         @schema = schema
+        @class_based = !!@schema.is_a?(Class)
         @built_in_namespace = GraphQL::Introspection
-        @custom_namespace = schema.introspection_namespace || @built_in_namespace
-
-        # Use to-graphql to avoid sharing with any previous instantiations
-        @schema_type = load_constant(:SchemaType).to_graphql
-        @type_type = load_constant(:TypeType).to_graphql
-        @field_type = load_constant(:FieldType).to_graphql
-        @directive_type = load_constant(:DirectiveType).to_graphql
-        @enum_value_type = load_constant(:EnumValueType).to_graphql
-        @input_value_type = load_constant(:InputValueType).to_graphql
-        @type_kind_enum = load_constant(:TypeKindEnum).to_graphql
-        @directive_location_enum = load_constant(:DirectiveLocationEnum).to_graphql
+        @custom_namespace = if @class_based
+          schema.introspection || @built_in_namespace
+        else
+          schema.introspection_namespace || @built_in_namespace
+        end
+
+        type_defns = [
+          load_constant(:SchemaType),
+          load_constant(:TypeType),
+          load_constant(:FieldType),
+          load_constant(:DirectiveType),
+          load_constant(:EnumValueType),
+          load_constant(:InputValueType),
+          load_constant(:TypeKindEnum),
+          load_constant(:DirectiveLocationEnum)
+        ]
+        @types = {}
+        @possible_types = {}
+        type_defns.each do |t|
+          @types[t.graphql_name] = t
+          @possible_types[t.graphql_name] = [t]
+        end
         @entry_point_fields =
-          if schema.disable_introspection_entry_points
+          if schema.disable_introspection_entry_points?
             {}
           else
-            get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields.delete('__schema') if schema.disable_schema_introspection_entry_point?
+            entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point?
+            entry_point_fields
           end
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
       end
 
-      def object_types
-        [
-          @schema_type,
-          @type_type,
-          @field_type,
-          @directive_type,
-          @enum_value_type,
-          @input_value_type,
-          @type_kind_enum,
-          @directive_location_enum,
-        ]
-      end
-
       def entry_points
         @entry_point_fields.values
       end
@@ -56,25 +58,94 @@ module GraphQL
         @dynamic_fields[name]
       end
 
+      # The introspection system is prepared with a bunch of LateBoundTypes.
+      # Replace those with the objects that they refer to, since LateBoundTypes
+      # aren't handled at runtime.
+      #
+      # @api private
+      # @return void
+      def resolve_late_bindings
+        @types.each do |name, t|
+          if t.kind.fields?
+            t.fields.each do |_name, field_defn|
+              field_defn.type = resolve_late_binding(field_defn.type)
+            end
+          end
+        end
+
+        @entry_point_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+
+        @dynamic_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+        nil
+      end
+
       private
 
+      def resolve_late_binding(late_bound_type)
+        case late_bound_type
+        when GraphQL::Schema::LateBoundType
+          @schema.get_type(late_bound_type.name)
+        when GraphQL::Schema::List, GraphQL::ListType
+          resolve_late_binding(late_bound_type.of_type).to_list_type
+        when GraphQL::Schema::NonNull, GraphQL::NonNullType
+          resolve_late_binding(late_bound_type.of_type).to_non_null_type
+        when Module
+          # It's a normal type -- no change required
+          late_bound_type
+        else
+          raise "Invariant: unexpected type: #{late_bound_type} (#{late_bound_type.class})"
+        end
+      end
+
       def load_constant(class_name)
-        @custom_namespace.const_get(class_name)
+        const = @custom_namespace.const_get(class_name)
+        if @class_based
+          dup_type_class(const)
+        else
+          # Use `.to_graphql` to get a freshly-made version, not shared between schemas
+          const.to_graphql
+        end
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared
-        @built_in_namespace.const_get(class_name)
+        dup_type_class(@built_in_namespace.const_get(class_name))
       end
 
       def get_fields_from_class(class_sym:)
-        object_class = load_constant(class_sym)
-        object_type_defn = object_class.to_graphql
-        extracted_field_defns = {}
-        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)
+        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
+      end
+
+      # This is probably not 100% robust -- but it has to be good enough to avoid modifying the built-in introspection types
+      def dup_type_class(type_class)
+        type_name = type_class.graphql_name
+        Class.new(type_class) do
+          # This won't be inherited like other things will
+          graphql_name(type_name)
+
+          if type_class.kind.fields?
+            type_class.fields.each do |_name, field_defn|
+              dup_field = field_defn.dup
+              dup_field.owner = self
+              add_field(dup_field)
+            end
+          end
         end
-        extracted_field_defns
       end
 
       class PerFieldProxyResolve

data/lib/graphql/schema/late_bound_type.rb

@@ -6,6 +6,7 @@ module GraphQL
     # @api Private
     class LateBoundType
       attr_reader :name
+      alias :graphql_name :name
       def initialize(local_name)
         @name = local_name
       end

data/lib/graphql/schema/list.rb

@@ -6,6 +6,8 @@ module GraphQL
     # Wraps a {Schema::Member} as a list type.
     # @see {Schema::Member::TypeSystemHelpers#to_list_type}
     class List < GraphQL::Schema::Wrapper
+      include Schema::Member::ValidatesInput
+
       def to_graphql
         @of_type.graphql_definition.to_list_type
       end
@@ -23,6 +25,45 @@ module GraphQL
       def to_type_signature
         "[#{@of_type.to_type_signature}]"
       end
+
+      # This is for introspection, where it's expected the name will be `null`
+      def graphql_name
+        nil
+      end
+
+      def coerce_result(value, ctx)
+        value.map { |i| i.nil? ? nil : of_type.coerce_result(i, ctx) }
+      end
+
+      def coerce_input(value, ctx)
+        if value.nil?
+          nil
+        else
+          ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+        end
+      end
+
+      def validate_non_null_input(value, ctx)
+        result = GraphQL::Query::InputValidationResult.new
+        ensure_array(value).each_with_index do |item, index|
+          item_result = of_type.validate_input(item, ctx)
+          if !item_result.valid?
+            result.merge_result!(index, item_result)
+          end
+        end
+        result
+      end
+
+      private
+
+      def ensure_array(value)
+        # `Array({ a: 1 })` makes `[[:a, 1]]`, so do it manually
+        if value.is_a?(Array)
+          value
+        else
+          [value]
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/loader.rb

@@ -45,7 +45,13 @@ module GraphQL
         def resolve_type(types, type)
           case kind = type.fetch("kind")
           when "ENUM", "INTERFACE", "INPUT_OBJECT", "OBJECT", "SCALAR", "UNION"
-            types.fetch(type.fetch("name"))
+            type_name = type.fetch("name")
+            type = types[type_name] || Schema::BUILT_IN_TYPES[type_name]
+            if type.nil?
+              raise "Type not found: #{type_name.inspect} among #{types.keys.sort}"
+            else
+              type.graphql_definition
+            end
           when "LIST"
             ListType.new(of_type: resolve_type(types, type.fetch("ofType")))
           when "NON_NULL"
@@ -118,14 +124,20 @@ module GraphQL
               }]
             )
           when "FIELD"
-            GraphQL::Field.define(
+            defns = {
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
-              arguments: Hash[type["args"].map { |arg|
+            }
+
+            # Avoid passing an empty hash, which warns on Ruby 2.7
+            if type["args"].any?
+              defns[:arguments] = Hash[type["args"].map { |arg|
                 [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
               }]
-            )
+            end
+
+            GraphQL::Field.define(**defns)
           when "ARGUMENT"
             kwargs = {}
             if type["defaultValue"]

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

@@ -18,16 +18,17 @@ module GraphQL
         # @param new_name [String]
         # @return [String]
         def graphql_name(new_name = nil)
-          case
-          when new_name
+          if new_name
             @graphql_name = new_name
-          when overridden = overridden_graphql_name
-            overridden
           else
-            default_graphql_name
+            overridden_graphql_name || default_graphql_name
           end
         end
 
+        def overridden_graphql_name
+          @graphql_name
+        end
+
         # Just a convenience method to point out that people should use graphql_name instead
         def name(new_name = nil)
           return super() if new_name.nil?
@@ -46,7 +47,20 @@ module GraphQL
           if new_description
             @description = new_description
           else
-            @description || find_inherited_value(:description)
+            @description
+          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)
+            if overridden_graphql_name
+              child_class.graphql_name(overridden_graphql_name)
+            end
+            super
           end
         end
 
@@ -55,7 +69,7 @@ module GraphQL
           if !new_introspection.nil?
             @introspection = new_introspection
           else
-            @introspection || find_inherited_value(:introspection, false)
+            @introspection
           end
         end
 
@@ -79,10 +93,6 @@ module GraphQL
 
         alias :unwrap :itself
 
-        def overridden_graphql_name
-          @graphql_name || find_inherited_value(:overridden_graphql_name)
-        end
-
         # Creates the default name for a schema member.
         # The default name is the Ruby constant name,
         # without any namespaces and with any `-Type` suffix removed

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

@@ -64,6 +64,8 @@ module GraphQL
             else
               raise ArgumentError, LIST_TYPE_ERROR
             end
+          when GraphQL::Schema::NonNull, GraphQL::Schema::List
+            type_expr
           when Module
             # This is a way to check that it's the right kind of module:
             if type_expr.respond_to?(:graphql_definition)
@@ -72,12 +74,14 @@ module GraphQL
               # Eg `String` => GraphQL::STRING_TYPE
               parse_type(type_expr.name, null: true)
             end
+          when Proc
+            parse_type(type_expr.call, null: true)
           when false
             raise ArgumentError, "Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
           end
 
           if return_type.nil?
-            raise "Unexpected type input: #{type_expr} (#{type_expr.class})"
+            raise "Unexpected type input: #{type_expr.inspect} (#{type_expr.class})"
           end
 
           # Apply list_type first, that way the

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

@@ -15,6 +15,11 @@ module GraphQL
           @graphql_definition ||= to_graphql
         end
 
+        # This is for a common interface with .define-based types
+        def type_class
+          self
+        end
+
         # Wipe out the cached graphql_definition so that `.to_graphql` will be called again.
         def initialize_copy(original)
           super

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

@@ -97,7 +97,7 @@ module GraphQL
               # (Don't want to allow arbitrary access to objects this way)
               resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
               context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
-                possible_object_types = context.schema.possible_types(lookup_as_type)
+                possible_object_types = context.warden.possible_types(lookup_as_type)
                 if !possible_object_types.include?(application_object_type)
                   err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
                   load_application_object_failed(err)
@@ -105,7 +105,7 @@ module GraphQL
                   # This object was loaded successfully
                   # and resolved to the right type,
                   # now apply the `.authorized?` class method if there is one
-                  if (class_based_type = application_object_type.metadata[:type_class])
+                  if (class_based_type = application_object_type.type_class)
                     context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
                       if authed
                         application_object

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasAstNode
+        # If this schema was parsed from a `.graphql` file (or other SDL),
+        # this is the AST node that defined this part of the schema.
+        def ast_node(new_ast_node = nil)
+          if new_ast_node
+            @ast_node = new_ast_node
+          end
+          @ast_node
+        end
+      end
+    end
+  end
+end

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
@@ -59,8 +59,8 @@ module GraphQL
         # @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}`)"
+          if CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.method_conflict_warning?
+            warn "#{self.graphql_name}'s `field :#{field_defn.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
           own_fields[field_defn.name] = field_defn
           nil

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,12 @@ 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/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 +22,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

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,29 @@ 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
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -57,13 +57,9 @@ module GraphQL
                 else
                   nil
                 end
-              # rescue GraphQL::ExecutionError => err
-              #   err
               end
             end
           end
-        # rescue GraphQL::ExecutionError => err
-        #   err
         end
       end
 
@@ -86,11 +82,24 @@ module GraphQL
               include(int)
             end
           end
+          # Remove any interfaces which are being replaced (late-bound types are updated in place this way)
+          own_interfaces.reject! { |i|
+            new_interfaces.any? { |new_i|
+              new_name = new_i.is_a?(String) ? new_i : new_i.graphql_name
+              old_name = i.is_a?(String) ? i : i.graphql_name
+              new_name == old_name
+            }
+          }
           own_interfaces.concat(new_interfaces)
         end
 
         def interfaces
-          own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
+          inherited_interfaces = (superclass.respond_to?(:interfaces) ? superclass.interfaces : nil)
+          if inherited_interfaces && !inherited_interfaces.empty?
+            own_interfaces + inherited_interfaces
+          else
+            own_interfaces
+          end
         end
 
         def own_interfaces
@@ -120,6 +129,7 @@ module GraphQL
           obj_type.interfaces = interfaces
           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/printer.rb

@@ -54,7 +54,6 @@ module GraphQL
         )
 
         @document = @document_from_schema.document
-
         @schema = schema
       end
 
@@ -99,7 +98,7 @@ module GraphQL
         if directive.name == "deprecated"
           reason = directive.arguments.find { |arg| arg.name == "reason" }
 
-          if reason.value == GraphQL::Directive::DEFAULT_DEPRECATION_REASON
+          if reason.value == GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON
             "@deprecated"
           else
             "@deprecated(reason: #{reason.value.to_s.inspect})"

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

data/lib/graphql/schema/resolver.rb

@@ -76,7 +76,7 @@ module GraphQL
             context.schema.after_lazy(load_arguments_val) do |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 +135,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