graphql 1.11.6 → 1.13.19

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to specifically reject values that respond to `.blank?` and respond truthy for that method.
+      #
+      # @example Require a non-empty string for an argument
+      #   argument :name, String, required: true, validate: { allow_blank: false }
+      class AllowBlankValidator < Validator
+        def initialize(allow_blank_positional, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
+          @message = message
+          super(**default_options)
+          @allow_blank = allow_blank.nil? ? allow_blank_positional : allow_blank
+        end
+
+        def validate(_object, _context, value)
+          if value.respond_to?(:blank?) && value.blank?
+            if (value.nil? && @allow_null) || @allow_blank
+              # pass
+            else
+              @message
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to specifically reject or permit `nil` values (given as `null` from GraphQL).
+      #
+      # @example require a non-null value for an argument if it is provided
+      #   argument :name, String, required: false, validates: { allow_null: false }
+      class AllowNullValidator < Validator
+        MESSAGE = "%{validated} can't be null"
+        def initialize(allow_null_positional, allow_null: nil, message: MESSAGE, **default_options)
+          @message = message
+          super(**default_options)
+          @allow_null = allow_null.nil? ? allow_null_positional : allow_null
+        end
+
+        def validate(_object, _context, value)
+          if value.nil? && !@allow_null
+            @message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# 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 permitted_empty_value?(value)
+            # pass
+          elsif @in_list.include?(value)
+            @message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# 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
+        # @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 permitted_empty_value?(value)
+            # Do nothing
+          elsif value.nil? ||
+              (@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,35 @@
+# 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 permitted_empty_value?(value)
+            # pass
+          elsif !@in_list.include?(value)
+            @message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to enforce a `.length` restriction on incoming values. It works for both Strings and Lists.
+      #
+      # @example Allow no more than 10 IDs
+      #
+      #   argument :ids, [ID], required: true, validates: { length: { maximum: 10 } }
+      #
+      # @example Require three selections
+      #
+      #   argument :ice_cream_preferences, [ICE_CREAM_FLAVOR], required: true, validates: { length: { is: 3 } }
+      #
+      class LengthValidator < Validator
+        # @param maximum [Integer]
+        # @param too_long [String] Used when `maximum` is exceeded or value is greater than `within`
+        # @param minimum [Integer]
+        # @param too_short [String] Used with value is less than `minimum` or less than `within`
+        # @param is [Integer] Exact length requirement
+        # @param wrong_length [String] Used when value doesn't match `is`
+        # @param within [Range] An allowed range (becomes `minimum:` and `maximum:` under the hood)
+        # @param message [String]
+        def initialize(
+          maximum: nil, too_long: "%{validated} is too long (maximum is %{count})",
+          minimum: nil, too_short: "%{validated} is too short (minimum is %{count})",
+          is: nil, within: nil, wrong_length: "%{validated} is the wrong length (should be %{count})",
+          message: nil,
+          **default_options
+        )
+          if within && (minimum || maximum)
+            raise ArgumentError, "`length: { ... }` may include `within:` _or_ `minimum:`/`maximum:`, but not both"
+          end
+          # Under the hood, `within` is decomposed into `minimum` and `maximum`
+          @maximum = maximum || (within && within.max)
+          @too_long = message || too_long
+          @minimum = minimum || (within && within.min)
+          @too_short = message || too_short
+          @is = is
+          @wrong_length = message || wrong_length
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          return if permitted_empty_value?(value) # pass in this case
+          length = value.nil? ? 0 : value.length
+          if @maximum && length > @maximum
+            partial_format(@too_long, { count: @maximum })
+          elsif @minimum && length < @minimum
+            partial_format(@too_short, { count: @minimum })
+          elsif @is && length != @is
+            partial_format(@wrong_length, { count: @is })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to assert numerical comparisons hold true for inputs.
+      #
+      # @example Require a number between 0 and 1
+      #
+      #   argument :batting_average, Float, required: true, validates: { numericality: { within: 0..1 } }
+      #
+      # @example Require the number 42
+      #
+      #   argument :the_answer, Integer, required: true, validates: { numericality: { equal_to: 42 } }
+      #
+      # @example Require a real number
+      #
+      #   argument :items_count, Integer, required: true, validates: { numericality: { greater_than_or_equal_to: 0 } }
+      #
+      class NumericalityValidator < Validator
+        # @param greater_than [Integer]
+        # @param greater_than_or_equal_to [Integer]
+        # @param less_than [Integer]
+        # @param less_than_or_equal_to [Integer]
+        # @param equal_to [Integer]
+        # @param other_than [Integer]
+        # @param odd [Boolean]
+        # @param even [Boolean]
+        # @param within [Range]
+        # @param message [String] used for all validation failures
+        def initialize(
+            greater_than: nil, greater_than_or_equal_to: nil,
+            less_than: nil, less_than_or_equal_to: nil,
+            equal_to: nil, other_than: nil,
+            odd: nil, even: nil, within: nil,
+            message: "%{validated} must be %{comparison} %{target}",
+            null_message: Validator::AllowNullValidator::MESSAGE,
+            **default_options
+          )
+
+          @greater_than = greater_than
+          @greater_than_or_equal_to = greater_than_or_equal_to
+          @less_than = less_than
+          @less_than_or_equal_to = less_than_or_equal_to
+          @equal_to = equal_to
+          @other_than = other_than
+          @odd = odd
+          @even = even
+          @within = within
+          @message = message
+          @null_message = null_message
+          super(**default_options)
+        end
+
+        def validate(object, context, value)
+          if permitted_empty_value?(value)
+            # pass in this case
+          elsif value.nil? # @allow_null is handled in the parent class
+            @null_message
+          elsif @greater_than && value <= @greater_than
+            partial_format(@message, { comparison: "greater than", target: @greater_than })
+          elsif @greater_than_or_equal_to && value < @greater_than_or_equal_to
+            partial_format(@message, { comparison: "greater than or equal to", target: @greater_than_or_equal_to })
+          elsif @less_than && value >= @less_than
+            partial_format(@message, { comparison: "less than", target: @less_than })
+          elsif @less_than_or_equal_to && value > @less_than_or_equal_to
+            partial_format(@message, { comparison: "less than or equal to", target: @less_than_or_equal_to })
+          elsif @equal_to && value != @equal_to
+            partial_format(@message, { comparison: "equal to", target: @equal_to })
+          elsif @other_than && value == @other_than
+            partial_format(@message, { comparison: "something other than", target: @other_than })
+          elsif @even && !value.even?
+            (partial_format(@message, { comparison: "even", target: "" })).strip
+          elsif @odd && !value.odd?
+            (partial_format(@message, { comparison: "odd", target: "" })).strip
+          elsif @within && !@within.include?(value)
+            partial_format(@message, { comparison: "within", target: @within })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this validator to require _one_ of the named arguments to be present.
+      # Or, use Arrays of symbols to name a valid _set_ of arguments.
+      #
+      # (This is for specifying mutually exclusive sets of arguments.)
+      #
+      # @example Require exactly one of these arguments
+      #
+      #   field :update_amount, IngredientAmount, null: false do
+      #     argument :ingredient_id, ID, required: true
+      #     argument :cups, Integer, required: false
+      #     argument :tablespoons, Integer, required: false
+      #     argument :teaspoons, Integer, required: false
+      #     validates required: { one_of: [:cups, :tablespoons, :teaspoons] }
+      #   end
+      #
+      # @example Require one of these _sets_ of arguments
+      #
+      #  field :find_object, Node, null: true do
+      #    argument :node_id, ID, required: false
+      #    argument :object_type, String, required: false
+      #    argument :object_id, Integer, required: false
+      #    # either a global `node_id` or an `object_type`/`object_id` pair is required:
+      #    validates required: { one_of: [:node_id, [:object_type, :object_id]] }
+      #  end
+      #
+      # @example require _some_ value for an argument, even if it's null
+      #   field :update_settings, AccountSettings do
+      #     # `required: :nullable` means this argument must be given, but may be `null`
+      #     argument :age, Integer, required: :nullable
+      #   end
+      #
+      class RequiredValidator < Validator
+        # @param one_of [Symbol, Array<Symbol>] An argument, or a list of arguments, that represents a valid set of inputs for this field
+        # @param message [String]
+        def initialize(one_of: nil, argument: nil, message: "%{validated} has the wrong arguments", **default_options)
+          @one_of = if one_of
+            one_of
+          elsif argument
+            [argument]
+          else
+            raise ArgumentError, "`one_of:` or `argument:` must be given in `validates required: {...}`"
+          end
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          matched_conditions = 0
+
+          if !value.nil?
+            @one_of.each do |one_of_condition|
+              case one_of_condition
+              when Symbol
+                if value.key?(one_of_condition)
+                  matched_conditions += 1
+                end
+              when Array
+                if one_of_condition.all? { |k| value.key?(k) }
+                  matched_conditions += 1
+                  break
+                end
+              else
+                raise ArgumentError, "Unknown one_of condition: #{one_of_condition.inspect}"
+              end
+            end
+          end
+
+          if matched_conditions == 1
+            nil # OK
+          else
+            @message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator.rb

@@ -0,0 +1,171 @@
+# 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
+
+      # @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 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
+
+      # @return [Boolean] `true` if `value` is `nil` and this validator has `allow_null: true` or if value is `.blank?` and this validator has `allow_blank: true`
+      def permitted_empty_value?(value)
+        (value.nil? && @allow_null) ||
+          (@allow_blank && value.respond_to?(:blank?) && value.blank?)
+      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 = validates_hash.dup
+
+          default_options = {}
+          if validates_hash[:allow_null]
+            default_options[:allow_null] = validates_hash.delete(:allow_null)
+          end
+          if validates_hash[:allow_blank]
+            default_options[:allow_blank] = validates_hash.delete(:allow_blank)
+          end
+
+          # allow_nil or allow_blank are the _only_ validations:
+          if validates_hash.empty?
+            validates_hash = default_options
+          end
+
+          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
+            if options.is_a?(Hash)
+              validator_class.new(validated: schema_member, **(default_options.merge(options)))
+            else
+              validator_class.new(options, validated: schema_member, **default_options)
+            end
+          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.validate(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)
+require "graphql/schema/validator/allow_null_validator"
+GraphQL::Schema::Validator.install(:allow_null, GraphQL::Schema::Validator::AllowNullValidator)
+require "graphql/schema/validator/allow_blank_validator"
+GraphQL::Schema::Validator.install(:allow_blank, GraphQL::Schema::Validator::AllowBlankValidator)