graphql 1.11.10 → 1.12.0

data/lib/graphql/schema/input_object.rb

@@ -7,6 +7,7 @@ module GraphQL
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader
       extend GraphQL::Schema::Member::ValidatesInput
+      extend GraphQL::Schema::Member::HasValidators
 
       include GraphQL::Dig
 
@@ -37,14 +38,15 @@ module GraphQL
                 load_application_object(arg_defn, loads, value, context)
               end
               maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
-                @ruby_style_hash[ruby_kwargs_key] = loaded_value
+                overwrite_argument(ruby_kwargs_key, loaded_value)
               end
             end
 
             # 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? || !context.interpreter?
-              @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              overwrite_argument(ruby_kwargs_key, prepared_value)
             end
           end
         end
@@ -74,6 +76,9 @@ module GraphQL
       def prepare
         if context
           context.schema.after_any_lazies(@maybe_lazies) do
+            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
           end
         else
@@ -168,17 +173,10 @@ module GraphQL
             return result
           end
 
-          input = begin
-            input.to_h
-          rescue
-            begin
-              # Handle ActionController::Parameters:
-              input.to_unsafe_h
-            rescue
-              # We're not sure it'll act like a hash, so reject it:
-              result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-              return result
-            end
+          if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
+            # We're not sure it'll act like a hash, so reject it:
+            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return result
           end
 
           # Inject missing required arguments
@@ -190,16 +188,19 @@ module GraphQL
             m
           end
 
-          input.merge(missing_required_inputs).each do |argument_name, value|
-            argument = warden.get_argument(self, argument_name)
-            # Items in the input that are unexpected
-            unless argument
-              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              next
+
+          [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
+              unless argument
+                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+                next
+              end
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              result.merge_result!(argument_name, argument_result) unless argument_result.valid?
             end
-            # Items in the input that are expected, but have invalid values
-            argument_result = argument.type.validate_input(value, ctx)
-            result.merge_result!(argument_name, argument_result) unless argument_result.valid?
           end
 
           result
@@ -240,6 +241,16 @@ module GraphQL
           result
         end
       end
+
+      private
+
+      def overwrite_argument(key, value)
+        # Argument keywords come in frozen from the interpreter, dup them before modifying them.
+        if @ruby_style_hash.frozen?
+          @ruby_style_hash = @ruby_style_hash.dup
+        end
+        @ruby_style_hash[key] = value
+      end
     end
   end
 end

data/lib/graphql/schema/interface.rb

@@ -15,6 +15,7 @@ module GraphQL
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
         include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDirectives
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface

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

@@ -19,6 +19,7 @@ module GraphQL
         # @return [String]
         def graphql_name(new_name = nil)
           if new_name
+            GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
           else
             overridden_graphql_name || default_graphql_name

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

@@ -60,11 +60,11 @@ module GraphQL
               parse_type(type_expr.first, null: false)
             when 2
               inner_type, nullable_option = type_expr
-              if nullable_option.keys != [:null] || nullable_option.values != [true]
+              if nullable_option.keys != [:null] || (nullable_option[:null] != true && nullable_option[:null] != false)
                 raise ArgumentError, LIST_TYPE_ERROR
               end
               list_type = true
-              parse_type(inner_type, null: true)
+              parse_type(inner_type, null: nullable_option[:null])
             else
               raise ArgumentError, LIST_TYPE_ERROR
             end
@@ -75,7 +75,7 @@ module GraphQL
             if type_expr.respond_to?(:graphql_definition)
               type_expr
             else
-              # Eg `String` => GraphQL::STRING_TYPE
+              # Eg `String` => GraphQL::Types::String
               parse_type(type_expr.name, null: true)
             end
           when Proc

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

@@ -89,7 +89,7 @@ module GraphQL
           arg_defns = self.arguments
 
           if arg_defns.empty?
-            GraphQL::Execution::Interpreter::Arguments.new(argument_values: nil)
+            GraphQL::Execution::Interpreter::Arguments::EMPTY
           else
             argument_values = {}
             arg_lazies = arg_defns.map do |arg_name, arg_defn|
@@ -111,24 +111,28 @@ module GraphQL
               if has_value
                 loads = arg_defn.loads
                 loaded_value = nil
+                coerced_value = context.schema.error_handler.with_error_handling(context) do
+                  arg_defn.type.coerce_input(value, context)
+                end
+
+                # TODO this should probably be inside after_lazy
                 if loads && !arg_defn.from_resolver?
                   loaded_value = if arg_defn.type.list?
-                    loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                    loaded_values = coerced_value.map { |val| load_application_object(arg_defn, loads, val, context) }
                     context.schema.after_any_lazies(loaded_values) { |result| result }
                   else
-                    load_application_object(arg_defn, loads, value, context)
+                    load_application_object(arg_defn, loads, coerced_value, context)
                   end
                 end
 
                 coerced_value = if loaded_value
                   loaded_value
                 else
-                  context.schema.error_handler.with_error_handling(context) do
-                    arg_defn.type.coerce_input(value, context)
-                  end
+                  coerced_value
                 end
 
                 context.schema.after_lazy(coerced_value) do |coerced_value|
+                  validate_directive_argument(arg_defn, coerced_value)
                   prepared_value = context.schema.error_handler.with_error_handling(context) do
                     arg_defn.prepare_value(parent_object, coerced_value, context: context)
                   end
@@ -140,6 +144,9 @@ module GraphQL
                     default_used: default_used,
                   )
                 end
+              else
+                # has_value is false
+                validate_directive_argument(arg_defn, nil)
               end
             end
 
@@ -151,6 +158,17 @@ module GraphQL
           end
         end
 
+        # Usually, this is validated statically by RequiredArgumentsArePresent,
+        # but not for directives.
+        # TODO apply static validations on schema definitions?
+        def validate_directive_argument(arg_defn, value)
+          if arg_defn.owner.is_a?(Class) && arg_defn.owner < GraphQL::Schema::Directive
+            if value.nil? && arg_defn.type.non_null?
+              raise ArgumentError, "#{arg_defn.path} is required, but no value was given"
+            end
+          end
+        end
+
         def arguments_statically_coercible?
           return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
 

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDeprecationReason
+        # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
+        def deprecation_reason
+          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
+          dir && dir.arguments[:reason]
+        end
+
+        # Set the deprecation reason for this member, or remove it by assigning `nil`
+        # @param text [String, nil]
+        def deprecation_reason=(text)
+          if text.nil?
+            remove_directive(GraphQL::Schema::Directive::Deprecated)
+          else
+            directive(GraphQL::Schema::Directive::Deprecated, reason: text)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDirectives
+        # Create an instance of `dir_class` for `self`, using `options`.
+        #
+        # It removes a previously-attached instance of `dir_class`, if there is one.
+        #
+        # @return [void]
+        def directive(dir_class, **options)
+          @own_directives ||= []
+          remove_directive(dir_class)
+          @own_directives << dir_class.new(self, **options)
+          nil
+        end
+
+        # Remove an attached instance of `dir_class`, if there is one
+        # @param dir_class [Class<GraphQL::Schema::Directive>]
+        # @return [viod]
+        def remove_directive(dir_class)
+          @own_directives && @own_directives.reject! { |d| d.is_a?(dir_class) }
+          nil
+        end
+
+        NO_DIRECTIVES = [].freeze
+
+        def directives
+          case self
+          when Class
+            inherited_directives = if superclass.respond_to?(:directives)
+              superclass.directives
+            else
+              NO_DIRECTIVES
+            end
+            if inherited_directives.any? && @own_directives
+              dirs = []
+              merge_directives(dirs, inherited_directives)
+              merge_directives(dirs, @own_directives)
+              dirs
+            elsif @own_directives
+              @own_directives
+            elsif inherited_directives.any?
+              inherited_directives
+            else
+              NO_DIRECTIVES
+            end
+          when Module
+            dirs = nil
+            self.ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_directives) &&
+                  (anc_dirs = ancestor.own_directives).any?
+                dirs ||= []
+                merge_directives(dirs, anc_dirs)
+              end
+            end
+            if own_directives
+              dirs ||= []
+              merge_directives(dirs, own_directives)
+            end
+            dirs || NO_DIRECTIVES
+          when HasDirectives
+            @own_directives || NO_DIRECTIVES
+          else
+            raise "Invariant: how could #{self} not be a Class, Module, or instance of HasDirectives?"
+          end
+        end
+
+        protected
+
+        def own_directives
+          @own_directives
+        end
+
+        private
+
+        # Modify `target` by adding items from `dirs` such that:
+        # - Any name conflict is overriden by the incoming member of `dirs`
+        # - Any other member of `dirs` is appended
+        # @param target [Array<GraphQL::Schema::Directive>]
+        # @param dirs [Array<GraphQL::Schema::Directive>]
+        # @return [void]
+        def merge_directives(target, dirs)
+          dirs.each do |dir|
+            if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
+              target.slice!(idx)
+              target.insert(idx, dir)
+            else
+              target << dir
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasValidators
+        include Schema::FindInheritedValue::EmptyObjects
+
+        # Build {GraphQL::Schema::Validator}s based on the given configuration
+        # and use them for this schema member
+        # @param validation_config [Hash{Symbol => Hash}]
+        # @return [void]
+        def validates(validation_config)
+          new_validators = GraphQL::Schema::Validator.from_config(self, validation_config)
+          @own_validators ||= []
+          @own_validators.concat(new_validators)
+          nil
+        end
+
+        # @return [Array<GraphQL::Schema::Validator>]
+        def validators
+          own_validators = @own_validators || EMPTY_ARRAY
+          if self.is_a?(Class) && superclass.respond_to?(:validators) && (inherited_validators = superclass.validators).any?
+            inherited_validators + own_validators
+          else
+            own_validators
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module GraphQL
 
         # @return [GraphQL::TypeKinds::TypeKind]
         def kind
-          raise GraphQL::RequiredImplementationMissingError
+          raise GraphQL::RequiredImplementationMissingError, "No `.kind` defined for #{self}"
         end
       end
     end

data/lib/graphql/schema/member.rb

@@ -4,8 +4,11 @@ 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_directives'
+require 'graphql/schema/member/has_deprecation_reason'
 require 'graphql/schema/member/has_path'
 require 'graphql/schema/member/has_unresolved_type_error'
+require 'graphql/schema/member/has_validators'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
@@ -30,6 +33,7 @@ module GraphQL
       extend RelayShortcuts
       extend HasPath
       extend HasAstNode
+      extend HasDirectives
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -14,6 +14,17 @@ module GraphQL
       # @return [GraphQL::Query::Context] the context instance for this query
       attr_reader :context
 
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
+      # Call this in a field method to return a value that should be returned to the client
+      # without any further handling by GraphQL.
+      def raw_value(obj)
+        GraphQL::Execution::Interpreter::RawValue.new(obj)
+      end
+
       class << self
         # This is protected so that we can be sure callers use the public method, {.authorized_new}
         # @see authorized_new to make instances

data/lib/graphql/schema/printer.rb

@@ -59,14 +59,15 @@ module GraphQL
 
       # Return the GraphQL schema string for the introspection type system
       def self.print_introspection_schema
-        query_root = ObjectType.define(name: "Root") do
-          field :throwaway_field, types.String
+        query_root = Class.new(GraphQL::Schema::Object) do
+          graphql_name "Root"
+          field :throwaway_field, String, null: true
         end
-        schema = GraphQL::Schema.define(query: query_root)
+        schema = Class.new(GraphQL::Schema) { query(query_root) }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
-          except: ->(member, _) { member.name == "Root" },
+          except: ->(member, _) { member.graphql_name == "Root" },
           include_introspection_types: true,
           include_built_in_directives: true,
         ).document

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

@@ -44,6 +44,8 @@ module GraphQL
           end
         end
 
+        NO_INTERFACES = [].freeze
+
         private
 
         # Build a subclass of {.object_class} based on `self`.

data/lib/graphql/schema/resolver.rb

@@ -24,6 +24,7 @@ module GraphQL
       # Really we only need description from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
 
@@ -49,6 +50,11 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
@@ -80,6 +86,7 @@ module GraphQL
             load_arguments_val = load_arguments(args)
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
               @prepared_arguments = loaded_args
+              Schema::Validator.validate!(self.class.validators, object, context, loaded_args, as: @field)
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
                 authorized?(**loaded_args)

data/lib/graphql/schema/subscription.rb

@@ -25,6 +25,22 @@ module GraphQL
         @mode = context.query.subscription_update? ? :update : :subscribe
       end
 
+      def resolve_with_support(**args)
+        result = nil
+        unsubscribed = true
+        catch :graphql_subscription_unsubscribed do
+          result = super
+          unsubscribed = false
+        end
+
+
+        if unsubscribed
+          context.skip
+        else
+          result
+        end
+      end
+
       # Implement the {Resolve} API
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
@@ -55,7 +71,8 @@ module GraphQL
       def resolve_update(**args)
         ret_val = args.any? ? update(**args) : update
         if ret_val == :no_update
-          throw :graphql_no_subscription_update
+          context.namespace(:subscriptions)[:no_update] = true
+          context.skip
         else
           ret_val
         end
@@ -80,6 +97,7 @@ module GraphQL
 
       # Call this to halt execution and remove this subscription from the system
       def unsubscribe
+        context.namespace(:subscriptions)[:unsubscribed] = true
         throw :graphql_subscription_unsubscribed
       end
 

data/lib/graphql/schema/timeout_middleware.rb

@@ -23,6 +23,8 @@ module GraphQL
     #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
     #   end
     #
+    # @api deprecated
+    # @see Schema::Timeout
     class TimeoutMiddleware
       # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:, context_key: nil, &block)

data/lib/graphql/schema/validation.rb

@@ -6,6 +6,8 @@ module GraphQL
     # Its {RULES} contain objects that respond to `#call(type)`. Rules are
     # looked up for given types (by class ancestry), then applied to
     # the object until an error is returned.
+    #
+    # Remove this in GraphQL-Ruby 2.0 when schema instances are removed.
     class Validation
       # Lookup the rules for `object` based on its class,
       # Then returns an error message or `nil`

data/lib/graphql/schema/validator/exclusion_validator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to specifically reject values from an argument.
+      #
+      # @example disallow certain values
+      #
+      #   argument :favorite_non_prime, Integer, required: true,
+      #     validates: { exclusion: { in: [2, 3, 5, 7, ... ]} }
+      #
+      class ExclusionValidator < Validator
+        # @param message [String]
+        # @param in [Array] The values to reject
+        def initialize(message: "%{validated} is reserved", in:, **default_options)
+          # `in` is a reserved word, so work around that
+          @in_list = binding.local_variable_get(:in)
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          if @in_list.include?(value)
+            @message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator/format_validator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to assert that string values match (or don't match) the given RegExp.
+      #
+      # @example requiring input to match a pattern
+      #
+      #   argument :handle, String, required: true,
+      #     validates: { format: { with: /\A[a-z0-9_]+\Z/ } }
+      #
+      # @example reject inputs that match a pattern
+      #
+      #   argument :word_that_doesnt_begin_with_a_vowel, String, required: true,
+      #     validates: { format: { without: /\A[aeiou]/ } }
+      #
+      #   # It's pretty hard to come up with a legitimate use case for `without:`
+      #
+      class FormatValidator < Validator
+        if !String.method_defined?(:match?)
+          using GraphQL::StringMatchBackport
+        end
+
+        # @param with [RegExp, nil]
+        # @param without [Regexp, nil]
+        # @param message [String]
+        def initialize(
+          with: nil,
+          without: nil,
+          message: "%{validated} is invalid",
+          **default_options
+        )
+          @with_pattern = with
+          @without_pattern = without
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          if (@with_pattern && !value.match?(@with_pattern)) ||
+              (@without_pattern && value.match?(@without_pattern))
+            @message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator/inclusion_validator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # You can use this to allow certain values for an argument.
+      #
+      # Usually, a {GraphQL::Schema::Enum} is better for this, because it's self-documenting.
+      #
+      # @example only allow certain values for an argument
+      #
+      #   argument :favorite_prime, Integer, required: true,
+      #     validates: { inclusion: { in: [2, 3, 5, 7, 11, ... ] } }
+      #
+      class InclusionValidator < Validator
+        # @param message [String]
+        # @param in [Array] The values to allow
+        def initialize(in:, message: "%{validated} is not included in the list", **default_options)
+          # `in` is a reserved word, so work around that
+          @in_list = binding.local_variable_get(:in)
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          if !@in_list.include?(value)
+            @message
+          end
+        end
+      end
+    end
+  end
+end