graphql 1.10.0.pre1 → 1.10.0.pre2

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,30 @@ 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)
+        Array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+      end
+
+      def validate_non_null_input(value, ctx)
+        result = GraphQL::Query::InputValidationResult.new
+        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
     end
   end
 end

data/lib/graphql/schema/loader.rb

@@ -34,7 +34,7 @@ module GraphQL
       end
 
       NullResolveType = ->(type, obj, ctx) {
-        raise(NotImplementedError, "This schema was loaded from string, so it can't resolve types for objects")
+        raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
       }
 
       NullScalarCoerce = ->(val, _ctx) { val }
@@ -45,13 +45,19 @@ 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"
             NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
           else
-            fail NotImplementedError, "#{kind} not implemented"
+            fail GraphQL::RequiredImplementationMissingError, "#{kind} not implemented"
           end
         end
 
@@ -171,7 +177,7 @@ module GraphQL
               }
             )
           else
-            fail NotImplementedError, "#{type["kind"]} not implemented"
+            fail GraphQL::RequiredImplementationMissingError, "#{type["kind"]} not implemented"
           end
         end
       end

data/lib/graphql/schema/member.rb

@@ -8,6 +8,7 @@ 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
@@ -21,6 +22,8 @@ module GraphQL
       extend CachedGraphQLDefinition
       extend GraphQL::Relay::TypeExtensions
       extend BaseDSLMethods
+      extend BaseDSLMethods::ConfigurationExtension
+      introspection(false)
       extend TypeSystemHelpers
       extend Scoped
       extend RelayShortcuts

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
 
@@ -74,21 +88,17 @@ module GraphQL
 
         # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
         def to_graphql
-          raise NotImplementedError
+          raise GraphQL::RequiredImplementationMissingError
         end
 
         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
         def default_graphql_name
           @default_graphql_name ||= begin
-            raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
+            raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
 
             name.split("::").last.sub(/Type\Z/, "")
           end

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

@@ -81,7 +81,7 @@ module GraphQL
           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/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_fields.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'irb/ruby-token'
+
 module GraphQL
   class Schema
     class Member
@@ -38,16 +40,23 @@ module GraphQL
           end
         end
 
+        # A list of Ruby keywords.
+        #
+        # @api private
+        RUBY_KEYWORDS = RubyToken::TokenDefinitions.select { |definition| definition[1] == RubyToken::TkId }
+                                                   .map { |definition| definition[2] }
+                                                   .compact
+
+        # A list of GraphQL-Ruby keywords.
+        #
+        # @api private
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method]
+
         # 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 conflicts
-          :context, :object,
-          # Ruby built-ins conflicts
-          :method, :class
-        ])
+        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS)
 
         # Register this field with the class, overriding a previous one if needed.
         # @param field_defn [GraphQL::Schema::Field]

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

@@ -78,7 +78,7 @@ module GraphQL
 
           def call(obj, args, ctx)
             result = @inner_resolve.call(obj, args, ctx)
-            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || result.is_a?(GraphQL::ExecutionError) || ctx.wrapped_object
+            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || execution_errors?(result) || ctx.wrapped_object
               result
             else
               ctx.wrapped_object = true
@@ -88,6 +88,11 @@ module GraphQL
 
           private
 
+          def execution_errors?(result)
+            result.is_a?(GraphQL::ExecutionError) ||
+              (result.is_a?(Array) && result.any? && result.all? { |v| v.is_a?(GraphQL::ExecutionError) })
+          end
+
           def proxy_to_depth(inner_obj, depth, ctx)
             if depth > 0
               inner_obj.map { |i| proxy_to_depth(i, depth - 1, ctx) }

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

@@ -30,7 +30,7 @@ module GraphQL
 
         # @return [GraphQL::TypeKinds::TypeKind]
         def kind
-          raise NotImplementedError
+          raise GraphQL::RequiredImplementationMissingError
         end
       end
     end

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/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

@@ -84,11 +84,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

data/lib/graphql/schema/printer.rb

@@ -54,13 +54,14 @@ module GraphQL
         )
 
         @document = @document_from_schema.document
-
         @schema = schema
       end
 
       # Return the GraphQL schema string for the introspection type system
       def self.print_introspection_schema
-        query_root = ObjectType.define(name: "Root")
+        query_root = ObjectType.define(name: "Root") do
+          field :throwaway_field, types.String
+        end
         schema = GraphQL::Schema.define(query: query_root)
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
@@ -97,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

@@ -33,9 +33,13 @@ module GraphQL
         # But when using the interpreter, no instrumenters are applied.
         if context.interpreter?
           input = inputs[:input].to_kwargs
+
+          new_extras = field ? field.extras : []
+          all_extras = self.class.extras + new_extras
+
           # Transfer these from the top-level hash to the
           # shortcutted `input:` object
-          self.class.extras.each do |ext|
+          all_extras.each do |ext|
             # It's possible that the `extra` was not passed along by this point,
             # don't re-add it if it wasn't given here.
             if inputs.key?(ext)

data/lib/graphql/schema/resolver.rb

@@ -29,9 +29,11 @@ module GraphQL
 
       # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
       # @param context [GraphQL::Query::Context]
-      def initialize(object:, context:)
+      # @param field [GraphQL::Schema::Field]
+      def initialize(object:, context:, field:)
         @object = object
         @context = context
+        @field = field
         # Since this hash is constantly rebuilt, cache it for this call
         @arguments_by_keyword = {}
         self.class.arguments.each do |name, arg|
@@ -46,6 +48,9 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
+      # @return [GraphQL::Schema::Field]
+      attr_reader :field
+
       # This method is _actually_ called by the runtime,
       # it does some preparation and then eventually calls
       # the user-defined `#resolve` method.
@@ -103,7 +108,7 @@ module GraphQL
       # Do the work. Everything happens here.
       # @return [Object] An object corresponding to the return type
       def resolve(**args)
-        raise NotImplementedError, "#{self.class.name}#resolve should execute the field's logic"
+        raise GraphQL::RequiredImplementationMissingError, "#{self.class.name}#resolve should execute the field's logic"
       end
 
       # Called before arguments are prepared.
@@ -255,6 +260,7 @@ module GraphQL
             arguments: arguments,
             null: null,
             complexity: complexity,
+            extensions: extensions,
           }
         end
 
@@ -308,6 +314,18 @@ module GraphQL
           inherited_lookups.merge(own_arguments_loads_as_type)
         end
 
+        # Registers new extension
+        # @param extension [Class] Extension class
+        # @param options [Hash] Optional extension options
+        def extension(extension, **options)
+          extensions << {extension => options}
+        end
+
+        # @api private
+        def extensions
+          @extensions ||= []
+        end
+
         private
 
         def own_arguments_loads_as_type