graphql 1.10.0.pre1 → 1.10.0.pre2

data/lib/graphql/schema/argument.rb

@@ -116,7 +116,9 @@ module GraphQL
         elsif as_type.kind.input_object?
           as_type.arguments.each do |_name, input_obj_arg|
             input_obj_arg = input_obj_arg.type_class
-            if value.key?(input_obj_arg.keyword) &&  !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
+            # TODO: this skips input objects whose values were alread replaced with application objects.
+            # See: https://github.com/rmosolgo/graphql-ruby/issues/2633
+            if value.respond_to?(:key?) && value.key?(input_obj_arg.keyword) && !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
               return false
             end
           end
@@ -141,6 +143,8 @@ module GraphQL
         argument
       end
 
+      attr_writer :type
+
       def type
         @type ||= Member::BuildType.parse_type(@type_expr, null: @null)
       rescue StandardError => err
@@ -150,13 +154,25 @@ module GraphQL
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private
-      def prepare_value(obj, value)
+      def prepare_value(obj, value, context: nil)
+        if value.is_a?(GraphQL::Schema::InputObject)
+          value = value.prepare
+        end
+
         if @prepare.nil?
           value
         elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)
-          obj.public_send(@prepare, value)
+          if obj.nil?
+            # The problem here is, we _used to_ prepare while building variables.
+            # But now we don't have the runtime object there.
+            #
+            # This will have to be called later, when the runtime object _is_ available.
+            value
+          else
+            obj.public_send(@prepare, value)
+          end
         elsif @prepare.respond_to?(:call)
-          @prepare.call(value, obj.context)
+          @prepare.call(value, context || obj.context)
         else
           raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
         end

data/lib/graphql/schema/build_from_definition.rb

@@ -5,9 +5,9 @@ module GraphQL
   class Schema
     module BuildFromDefinition
       class << self
-        def from_definition(definition_string, default_resolve:, parser: DefaultParser)
+        def from_definition(definition_string, default_resolve:, using: {}, interpreter: true, parser: DefaultParser)
           document = parser.parse(definition_string)
-          Builder.build(document, default_resolve: default_resolve)
+          Builder.build(document, default_resolve: default_resolve, using: using, interpreter: interpreter)
         end
       end
 
@@ -29,34 +29,39 @@ module GraphQL
       module Builder
         extend self
 
-        def build(document, default_resolve: DefaultResolve)
+        def build(document, default_resolve: DefaultResolve, using: {}, interpreter: true)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
           if default_resolve.is_a?(Hash)
             default_resolve = ResolveMap.new(default_resolve)
           end
 
-          schema_definition = nil
+          schema_defns = document.definitions.select { |d| d.is_a?(GraphQL::Language::Nodes::SchemaDefinition) }
+          if schema_defns.size > 1
+            raise InvalidDocumentError.new('Must provide only one schema definition.')
+          end
+          schema_definition = schema_defns.first
           types = {}
           types.merge!(GraphQL::Schema::BUILT_IN_TYPES)
           directives = {}
-          type_resolver = ->(type) { -> { resolve_type(types, type) } }
+          type_resolver = ->(type) { resolve_type(types, type)  }
 
           document.definitions.each do |definition|
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition
-              raise InvalidDocumentError.new('Must provide only one schema definition.') if schema_definition
-              schema_definition = definition
+              nil # already handled
             when GraphQL::Language::Nodes::EnumTypeDefinition
-              types[definition.name] = build_enum_type(definition, type_resolver).graphql_definition
+              types[definition.name] = build_enum_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ObjectTypeDefinition
-              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve).graphql_definition
+              is_subscription_root = (definition.name == "Subscription" && (schema_definition.nil? || schema_definition.subscription.nil?)) || (schema_definition && (definition.name == schema_definition.subscription))
+              should_extend_subscription_root = is_subscription_root && interpreter
+              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve, extend_subscription_root: should_extend_subscription_root)
             when GraphQL::Language::Nodes::InterfaceTypeDefinition
-              types[definition.name] = build_interface_type(definition, type_resolver).graphql_definition
+              types[definition.name] = build_interface_type(definition, type_resolver)
             when GraphQL::Language::Nodes::UnionTypeDefinition
-              types[definition.name] = build_union_type(definition, type_resolver).graphql_definition
+              types[definition.name] = build_union_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ScalarTypeDefinition
-              types[definition.name] = build_scalar_type(definition, type_resolver, default_resolve: default_resolve).graphql_definition
+              types[definition.name] = build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
             when GraphQL::Language::Nodes::InputObjectTypeDefinition
               types[definition.name] = build_input_object_type(definition, type_resolver)
             when GraphQL::Language::Nodes::DirectiveDefinition
@@ -90,10 +95,18 @@ module GraphQL
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
           Class.new(GraphQL::Schema) do
-            query query_root_type
-            mutation mutation_root_type
-            subscription subscription_root_type
-            orphan_types types.values
+            begin
+              # Add these first so that there's some chance of resolving late-bound types
+              orphan_types types.values
+              query query_root_type
+              mutation mutation_root_type
+              subscription subscription_root_type
+            rescue Schema::UnresolvedLateBoundTypeError  => err
+              type_name = err.type.name
+              err_backtrace =  err.backtrace
+              raise InvalidDocumentError, "Type \"#{type_name}\" not found in document.", err_backtrace
+            end
+
             if default_resolve.respond_to?(:resolve_type)
               define_singleton_method(:resolve_type) do |*args|
                 default_resolve.resolve_type(*args)
@@ -110,13 +123,19 @@ module GraphQL
               ast_node(schema_definition)
             end
 
-            # Load caches, check for errors
-            graphql_definition
+            if interpreter
+              use GraphQL::Execution::Interpreter
+              use GraphQL::Analysis::AST
+            end
+
+            using.each do |plugin, options|
+              use(plugin, options)
+            end
           end
         end
 
         NullResolveType = ->(type, obj, ctx) {
-          raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
+          raise(GraphQL::RequiredImplementationMissingError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
         }
 
         def build_enum_type(enum_type_definition, type_resolver)
@@ -141,7 +160,7 @@ module GraphQL
           return unless deprecated_directive
 
           reason = deprecated_directive.arguments.find{ |a| a.name == 'reason' }
-          return GraphQL::Directive::DEFAULT_DEPRECATION_REASON unless reason
+          return GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON unless reason
 
           reason.value
         end
@@ -173,15 +192,19 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver, default_resolve:)
+        def build_object_type(object_type_definition, type_resolver, default_resolve:, extend_subscription_root:)
           builder = self
           type_def = nil
-          typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def.graphql_definition, field, obj, args, ctx) }
+          typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
           Class.new(GraphQL::Schema::Object) do
             type_def = self
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
+            if extend_subscription_root
+              # This has to come before `field ...` configurations since it modifies them
+              extend Subscriptions::SubscriptionRoot
+            end
 
             object_type_definition.interfaces.each do |interface_name|
               interface_defn = type_resolver.call(interface_name)
@@ -268,32 +291,42 @@ module GraphQL
           field_definitions.map do |field_definition|
             type_name = resolve_type_name(field_definition.type)
 
-            field = owner.field(
+            owner.field(
               field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
               null: true,
               connection: type_name.end_with?("Connection"),
-              resolve: ->(obj, args, ctx) { default_resolve.call(field.graphql_definition, obj, args, ctx) },
               deprecation_reason: build_deprecation_reason(field_definition.directives),
               ast_node: field_definition,
               method_conflict_warning: false,
               camelize: false,
             ) do
               builder.build_arguments(self, field_definition.arguments, type_resolver)
+
+              # Don't do this for interfaces
+              if default_resolve
+                # TODO fragile hack. formalize this API?
+                define_singleton_method :resolve_field_method do |obj, args, ctx|
+                  default_resolve.call(self, obj.object, args, ctx)
+                end
+              end
             end
           end
         end
 
         def resolve_type(types, ast_node)
-          type = GraphQL::Schema::TypeExpression.build_type(types, ast_node)
-          if type.nil?
-            while ast_node.respond_to?(:of_type)
-              ast_node = ast_node.of_type
-            end
-            raise InvalidDocumentError.new("Type \"#{ast_node.name}\" not found in document.")
+          case ast_node
+          when GraphQL::Language::Nodes::TypeName
+            type_name = ast_node.name
+            types[type_name] ||= GraphQL::Schema::LateBoundType.new(type_name)
+          when GraphQL::Language::Nodes::NonNullType
+            resolve_type(types, ast_node.of_type).to_non_null_type
+          when GraphQL::Language::Nodes::ListType
+            resolve_type(types, ast_node.of_type).to_list_type
+          else
+            raise "Unexpected ast_node: #{ast_node.inspect}"
           end
-          type
         end
 
         def resolve_type_name(type)

data/lib/graphql/schema/built_in_types.rb

@@ -2,11 +2,11 @@
 module GraphQL
   class Schema
     BUILT_IN_TYPES = {
-      "Int" => INT_TYPE,
-      "String" => STRING_TYPE,
-      "Float" => FLOAT_TYPE,
-      "Boolean" => BOOLEAN_TYPE,
-      "ID" => ID_TYPE,
+      "Int" => GraphQL::Types::Int,
+      "String" => GraphQL::Types::String,
+      "Float" => GraphQL::Types::Float,
+      "Boolean" => GraphQL::Types::Boolean,
+      "ID" => GraphQL::Types::ID,
     }
   end
 end

data/lib/graphql/schema/directive.rb

@@ -27,7 +27,7 @@ module GraphQL
           elsif @default_directive.nil?
             @default_directive = (superclass.respond_to?(:default_directive) ? superclass.default_directive : false)
           else
-            @default_directive
+            !!@default_directive
           end
         end
 
@@ -47,6 +47,9 @@ module GraphQL
             arg_graphql = arg_defn.to_graphql
             defn.arguments[arg_graphql.name] = arg_graphql
           end
+          # Make a reference to a classic-style Arguments class
+          defn.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(defn)
+
           defn
         end
 
@@ -59,6 +62,18 @@ module GraphQL
         def resolve(object, arguments, context)
           yield
         end
+
+        def on_field?
+          locations.include?(FIELD)
+        end
+
+        def on_fragment?
+          locations.include?(FRAGMENT_SPREAD) && locations.include?(INLINE_FRAGMENT)
+        end
+
+        def on_operation?
+          locations.include?(QUERY) && locations.include?(MUTATION) && locations.include?(SUBSCRIPTION)
+        end
       end
 
       LOCATIONS = [

data/lib/graphql/schema/directive/deprecated.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class Deprecated < GraphQL::Schema::Directive
+        description "Marks an element of a GraphQL schema as no longer supported."
+        locations(GraphQL::Schema::Directive::FIELD_DEFINITION, GraphQL::Schema::Directive::ENUM_VALUE)
+
+        reason_description = "Explains why this element was deprecated, usually also including a "\
+        "suggestion for how to access supported similar data. Formatted "\
+        "in [Markdown](https://daringfireball.net/projects/markdown/)."
+
+        argument :reason, String, reason_description, default_value: Directive::DEFAULT_DEPRECATION_REASON, required: false
+        default_directive true
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive/feature.rb

@@ -58,7 +58,7 @@ module GraphQL
         # @param context [GraphQL::Query::Context]
         # @return [Boolean] If truthy, execution will continue
         def self.enabled?(flag_name, object, context)
-          raise NotImplementedError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
+          raise GraphQL::RequiredImplementationMissingError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
         end
       end
     end

data/lib/graphql/schema/enum.rb

@@ -21,11 +21,9 @@ module GraphQL
   class Schema
     class Enum < 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, :coerce_input, :coerce_result
-
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
         # @param description [String], the GraphQL description for this value, present in documentation
@@ -73,6 +71,44 @@ module GraphQL
           GraphQL::TypeKinds::ENUM
         end
 
+        def validate_non_null_input(value_name, ctx)
+          result = GraphQL::Query::InputValidationResult.new
+
+          allowed_values = ctx.warden.enum_values(self)
+          matching_value = allowed_values.find { |v| v.graphql_name == value_name }
+
+          if matching_value.nil?
+            result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}")
+          end
+
+          result
+        end
+
+        def coerce_result(value, ctx)
+          warden = ctx.warden
+          all_values = warden ? warden.enum_values(self) : values.each_value
+          enum_value = all_values.find { |val| val.value == value }
+          if enum_value
+            enum_value.graphql_name
+          else
+            raise(GraphQL::EnumType::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+          end
+        end
+
+        def coerce_input(value_name, ctx)
+          all_values = ctx.warden ? ctx.warden.enum_values(self) : values.each_value
+
+          if v = all_values.find { |val| val.graphql_name == value_name }
+            v.value
+          elsif v = all_values.find { |val| val.value == value_name }
+            # this is for matching default values, which are "inputs", but they're
+            # the Ruby value, not the GraphQL string.
+            v.value
+          else
+            nil
+          end
+        end
+
         private
 
         def own_values

data/lib/graphql/schema/field.rb

@@ -15,6 +15,7 @@ module GraphQL
       include GraphQL::Schema::Member::HasArguments
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasPath
+      extend GraphQL::Schema::FindInheritedValue
 
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -35,7 +36,7 @@ module GraphQL
       attr_reader :resolver_method
 
       # @return [Class] The type that this field belongs to
-      attr_reader :owner
+      attr_accessor :owner
 
       # @return [Symbol] the original name of the field, passed in by the user
       attr_reader :original_name
@@ -51,7 +52,7 @@ module GraphQL
       attr_reader :trace
 
       # @return [String, nil]
-      attr_reader :subscription_scope
+      attr_accessor :subscription_scope
 
       # Create a field instance from a list of arguments, keyword arguments, and a block.
       #
@@ -136,6 +137,25 @@ module GraphQL
         end
       end
 
+      # This extension is applied to fields when {#connection?} is true.
+      #
+      # You can override it in your base field definition.
+      # @return [Class] A {FieldExtension} subclass for implementing pagination behavior.
+      # @example Configuring a custom extension
+      #   class Types::BaseField < GraphQL::Schema::Field
+      #     connection_extension(MyCustomExtension)
+      #   end
+      def self.connection_extension(new_extension_class = nil)
+        if new_extension_class
+          @connection_extension = new_extension_class
+        else
+          @connection_extension ||= find_inherited_value(:connection_extension, ConnectionExtension)
+        end
+      end
+
+      # @return Boolean
+      attr_reader :relay_node_field
+
       # @return [Boolean] Should we warn if this field's name conflicts with a built-in method?
       def method_conflict_warning?
         @method_conflict_warning
@@ -256,7 +276,7 @@ module GraphQL
         # The problem with putting this after the definition_block
         # is that it would override arguments
         if connection?
-          self.extension(ConnectionExtension)
+          self.extension(self.class.connection_extension)
         end
 
         if definition_block
@@ -340,7 +360,7 @@ module GraphQL
         end
       end
 
-      def complexity(new_complexity)
+      def complexity(new_complexity = nil)
         case new_complexity
         when Proc
           if new_complexity.parameters.size != 3
@@ -353,6 +373,8 @@ module GraphQL
           end
         when Numeric
           @complexity = new_complexity
+        when nil
+          @complexity
         else
           raise("Invalid complexity: #{new_complexity.inspect} on #{@name}")
         end
@@ -427,12 +449,20 @@ module GraphQL
 
         # Ok, `self` isn't a class, but this is for consistency with the classes
         field_defn.metadata[:type_class] = self
-
+        field_defn.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(field_defn)
         field_defn
       end
 
+      attr_writer :type
+
       def type
-        @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+        @type ||= if @function
+          Member::BuildType.parse_type(@function.type, null: false)
+        elsif @field
+          Member::BuildType.parse_type(@field.type, null: false)
+        else
+          Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+        end
       rescue GraphQL::Schema::InvalidDocumentError => err
         # Let this propagate up
         raise err
@@ -523,7 +553,7 @@ module GraphQL
                 else
                   extended_obj
                 end
-                @resolver_class.new(object: resolver_obj, context: ctx)
+                @resolver_class.new(object: resolver_obj, context: ctx, field: self)
               else
                 extended_obj
               end
@@ -597,7 +627,7 @@ module GraphQL
         elsif ctx.respond_to?(extra_name)
           ctx.public_send(extra_name)
         else
-          raise NotImplementedError, "Unknown field extra for #{self.path}: #{extra_name.inspect}"
+          raise GraphQL::RequiredImplementationMissingError, "Unknown field extra for #{self.path}: #{extra_name.inspect}"
         end
       end
 
@@ -640,7 +670,7 @@ module GraphQL
             if extended_obj.is_a?(GraphQL::Schema::Object)
               extended_obj = extended_obj.object
             end
-            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx)
+            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx, field: self)
           end
 
           if extended_obj.respond_to?(@resolver_method)