graphql 1.11.6 → 1.12.3

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/middleware_chain.rb

@@ -71,7 +71,7 @@ module GraphQL
 
       def wrap(callable)
         if BackwardsCompatibility.get_arity(callable) == 6
-          warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
+          GraphQL::Deprecation.warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
           MiddlewareWrapper.new(callable)
         else
           callable

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/relay_classic_mutation.rb

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

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/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/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,12 +23,14 @@ 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)
         @max_seconds = max_seconds
         if context_key
-          warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
+          GraphQL::Deprecation.warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
         end
         @error_handler = block
       end

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`
@@ -201,7 +203,7 @@ module GraphQL
         RESERVED_TYPE_NAME = ->(type) {
           if type.name.start_with?('__') && !type.introspection?
             # TODO: make this a hard failure in a later version
-            warn("Name #{type.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
+            GraphQL::Deprecation.warn("Name #{type.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
             nil
           else
             # ok name
@@ -211,7 +213,7 @@ module GraphQL
         RESERVED_NAME = ->(named_thing) {
           if named_thing.name.start_with?('__')
             # TODO: make this a hard failure in a later version
-            warn("Name #{named_thing.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
+            GraphQL::Deprecation.warn("Name #{named_thing.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
             nil
           else
             # no worries

data/lib/graphql/schema/validator.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # The thing being validated
+      # @return [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>]
+      attr_reader :validated
+
+      # TODO should this implement `if:` and `unless:` ?
+      # @param validated [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>] The argument or argument owner this validator is attached to
+      # @param allow_blank [Boolean] if `true`, then objects that respond to `.blank?` and return true for `.blank?` will skip this validation
+      # @param allow_null [Boolean] if `true`, then incoming `null`s will skip this validation
+      def initialize(validated:, allow_blank: false, allow_null: false)
+        @validated = validated
+        @allow_blank = allow_blank
+        @allow_null = allow_null
+      end
+
+      # @param object [Object] The application object that this argument's field is being resolved for
+      # @param context [GraphQL::Query::Context]
+      # @param value [Object] The client-provided value for this argument (after parsing and coercing by the input type)
+      # @return [nil, Array<String>, String] Error message or messages to add
+      def validate(object, context, value)
+        raise GraphQL::RequiredImplementationMissingError, "Validator classes should implement #validate"
+      end
+
+      # This is called by the validation system and eventually calls {#validate}.
+      # @api private
+      def apply(object, context, value)
+        if value.nil?
+          if @allow_null
+            nil # skip this
+          else
+            "%{validated} can't be null"
+          end
+        elsif value.respond_to?(:blank?) && value.blank?
+          if @allow_blank
+            nil # skip this
+          else
+            "%{validated} can't be blank"
+          end
+        else
+          validate(object, context, value)
+        end
+      end
+
+      # This is like `String#%`, but it supports the case that only some of `string`'s
+      # values are present in `substitutions`
+      def partial_format(string, substitutions)
+        substitutions.each do |key, value|
+          sub_v = value.is_a?(String) ? value : value.to_s
+          string = string.gsub("%{#{key}}", sub_v)
+        end
+        string
+      end
+
+      # @param schema_member [GraphQL::Schema::Field, GraphQL::Schema::Argument, Class<GraphQL::Schema::InputObject>]
+      # @param validates_hash [Hash{Symbol => Hash}, Hash{Class => Hash} nil] A configuration passed as `validates:`
+      # @return [Array<Validator>]
+      def self.from_config(schema_member, validates_hash)
+        if validates_hash.nil? || validates_hash.empty?
+          EMPTY_ARRAY
+        else
+          validates_hash.map do |validator_name, options|
+            validator_class = case validator_name
+            when Class
+              validator_name
+            else
+              all_validators[validator_name] || raise(ArgumentError, "unknown validation: #{validator_name.inspect}")
+            end
+            validator_class.new(validated: schema_member, **options)
+          end
+        end
+      end
+
+      # Add `validator_class` to be initialized when `validates:` is given `name`.
+      # (It's initialized with whatever options are given by the key `name`).
+      # @param name [Symbol]
+      # @param validator_class [Class]
+      # @return [void]
+      def self.install(name, validator_class)
+        all_validators[name] = validator_class
+        nil
+      end
+
+      # Remove whatever validator class is {.install}ed at `name`, if there is one
+      # @param name [Symbol]
+      # @return [void]
+      def self.uninstall(name)
+        all_validators.delete(name)
+        nil
+      end
+
+      class << self
+        attr_accessor :all_validators
+      end
+
+      self.all_validators = {}
+
+      include Schema::FindInheritedValue::EmptyObjects
+
+      class ValidationFailedError < GraphQL::ExecutionError
+        attr_reader :errors
+
+        def initialize(errors:)
+          @errors = errors
+          super(errors.join(", "))
+        end
+      end
+
+      # @param validators [Array<Validator>]
+      # @param object [Object]
+      # @param context [Query::Context]
+      # @param value [Object]
+      # @return [void]
+      # @raises [ValidationFailedError]
+      def self.validate!(validators, object, context, value, as: nil)
+        # Assuming the default case is no errors, reduce allocations in that case.
+        # This will be replaced with a mutable array if we actually get any errors.
+        all_errors = EMPTY_ARRAY
+
+        validators.each do |validator|
+          validated = as || validator.validated
+          errors = validator.apply(object, context, value)
+          if errors &&
+            (errors.is_a?(Array) && errors != EMPTY_ARRAY) ||
+            (errors.is_a?(String))
+            if all_errors.frozen? # It's empty
+              all_errors = []
+            end
+            interpolation_vars = { validated: validated.graphql_name }
+            if errors.is_a?(String)
+              all_errors << (errors % interpolation_vars)
+            else
+              errors = errors.map { |e| e % interpolation_vars }
+              all_errors.concat(errors)
+            end
+          end
+        end
+
+        if all_errors.any?
+          raise ValidationFailedError.new(errors: all_errors)
+        end
+        nil
+      end
+    end
+  end
+end
+
+
+require "graphql/schema/validator/length_validator"
+GraphQL::Schema::Validator.install(:length, GraphQL::Schema::Validator::LengthValidator)
+require "graphql/schema/validator/numericality_validator"
+GraphQL::Schema::Validator.install(:numericality, GraphQL::Schema::Validator::NumericalityValidator)
+require "graphql/schema/validator/format_validator"
+GraphQL::Schema::Validator.install(:format, GraphQL::Schema::Validator::FormatValidator)
+require "graphql/schema/validator/inclusion_validator"
+GraphQL::Schema::Validator.install(:inclusion, GraphQL::Schema::Validator::InclusionValidator)
+require "graphql/schema/validator/exclusion_validator"
+GraphQL::Schema::Validator.install(:exclusion, GraphQL::Schema::Validator::ExclusionValidator)
+require "graphql/schema/validator/required_validator"
+GraphQL::Schema::Validator.install(:required, GraphQL::Schema::Validator::RequiredValidator)