graphql_cody 1.13.0

data/lib/graphql/schema/validation.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # This module provides a function for validating GraphQL types.
+    #
+    # 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`
+      # @param object [Object] something to be validated
+      # @return [String, Nil] error message, if there was one
+      def self.validate(object)
+        RULES.each do |parent_class, validations|
+          if object.is_a?(parent_class)
+            validations.each do |rule|
+              if error = rule.call(object)
+                return error
+              end
+            end
+          end
+        end
+        nil
+      end
+
+      module Rules
+        # @param property_name [Symbol] The method to validate
+        # @param allowed_classes [Class] Classes which the return value may be an instance of
+        # @return [Proc] A proc which will validate the input by calling `property_name` and asserting it is an instance of one of `allowed_classes`
+        def self.assert_property(property_name, *allowed_classes)
+          # Hide LateBoundType from user-facing errors
+          allowed_classes_message = allowed_classes.map(&:name).reject {|n| n.include?("LateBoundType") }.join(" or ")
+          ->(obj) {
+            property_value = obj.public_send(property_name)
+            is_valid_value = allowed_classes.any? { |allowed_class| property_value.is_a?(allowed_class) }
+            is_valid_value ? nil : "#{property_name} must return #{allowed_classes_message}, not #{property_value.class.name} (#{property_value.inspect})"
+          }
+        end
+
+        # @param property_name [Symbol] The method whose return value will be validated
+        # @param from_class [Class] The class for keys in the return value
+        # @param to_class [Class] The class for values in the return value
+        # @return [Proc] A proc to validate that validates the input by calling `property_name` and asserting that the return value is a Hash of `{from_class => to_class}` pairs
+        def self.assert_property_mapping(property_name, from_class, to_class)
+          ->(obj) {
+            property_value = obj.public_send(property_name)
+            if !property_value.is_a?(Hash)
+              "#{property_name} must be a hash of {#{from_class.name} => #{to_class.name}}, not a #{property_value.class.name} (#{property_value.inspect})"
+            else
+              invalid_key, invalid_value = property_value.find { |key, value| !key.is_a?(from_class) || !value.is_a?(to_class) }
+              if invalid_key
+                "#{property_name} must map #{from_class} => #{to_class}, not #{invalid_key.class.name} => #{invalid_value.class.name} (#{invalid_key.inspect} => #{invalid_value.inspect})"
+              else
+                nil # OK
+              end
+            end
+          }
+        end
+
+        # @param property_name [Symbol] The method whose return value will be validated
+        # @param list_member_class [Class] The class which each member of the returned array should be an instance of
+        # @return [Proc] A proc to validate the input by calling `property_name` and asserting that the return is an Array of `list_member_class` instances
+        def self.assert_property_list_of(property_name, list_member_class)
+          ->(obj) {
+            property_value = obj.public_send(property_name)
+            if !property_value.is_a?(Array)
+              "#{property_name} must be an Array of #{list_member_class.name}, not a #{property_value.class.name} (#{property_value.inspect})"
+            else
+              invalid_member = property_value.find { |value| !value.is_a?(list_member_class) }
+              if invalid_member
+                "#{property_name} must contain #{list_member_class.name}, not #{invalid_member.class.name} (#{invalid_member.inspect})"
+              else
+                nil # OK
+              end
+            end
+          }
+        end
+
+        def self.count_at_least(item_name, minimum_count, get_items_proc)
+          ->(type) {
+            items = get_items_proc.call(type)
+
+            if items.size < minimum_count
+              "#{type.name} must define at least #{minimum_count} #{item_name}. #{items.size} defined."
+            else
+              nil
+            end
+          }
+        end
+
+        def self.assert_named_items_are_valid(item_name, get_items_proc)
+          ->(type) {
+            items = get_items_proc.call(type)
+            error_message = nil
+            items.each do |item|
+              item_message = GraphQL::Schema::Validation.validate(item)
+              if item_message
+                error_message = "#{item_name} #{item.name.inspect} #{item_message}"
+                break
+              end
+            end
+            error_message
+          }
+        end
+
+        HAS_AT_LEAST_ONE_FIELD = Rules.count_at_least("field", 1, ->(type) { type.all_fields })
+        FIELDS_ARE_VALID = Rules.assert_named_items_are_valid("field", ->(type) { type.all_fields })
+        HAS_AT_LEAST_ONE_ARGUMENT = Rules.count_at_least("argument", 1, ->(type) { type.arguments })
+
+        HAS_ONE_OR_MORE_POSSIBLE_TYPES = ->(type) {
+          type.possible_types.length >= 1 ? nil : "must have at least one possible type"
+        }
+
+        NAME_IS_STRING = Rules.assert_property(:name, String)
+        DESCRIPTION_IS_STRING_OR_NIL = Rules.assert_property(:description, String, NilClass)
+        ARGUMENTS_ARE_STRING_TO_ARGUMENT = Rules.assert_property_mapping(:arguments, String, GraphQL::Argument)
+        ARGUMENTS_ARE_VALID =  Rules.assert_named_items_are_valid("argument", ->(type) { type.arguments.values })
+
+        DEFAULT_VALUE_IS_VALID_FOR_TYPE = ->(type) {
+          if !type.default_value.nil?
+            coerced_value = begin
+              type.type.coerce_isolated_result(type.default_value)
+            rescue => ex
+              ex
+            end
+
+            if coerced_value.nil? || coerced_value.is_a?(StandardError)
+              msg = "default value #{type.default_value.inspect} is not valid for type #{type.type}"
+              msg += " (#{coerced_value})" if coerced_value.is_a?(StandardError)
+              msg
+            end
+          end
+        }
+
+        DEPRECATED_ARGUMENTS_ARE_OPTIONAL = ->(argument) {
+          if argument.deprecation_reason && argument.type.non_null?
+            "must be optional because it's deprecated"
+          end
+        }
+
+        TYPE_IS_VALID_INPUT_TYPE = ->(type) {
+          outer_type = type.type
+          inner_type = outer_type.respond_to?(:unwrap) ? outer_type.unwrap : nil
+
+          case inner_type
+          when GraphQL::ScalarType, GraphQL::InputObjectType, GraphQL::EnumType
+            # OK
+          else
+            "type must be a valid input type (Scalar or InputObject), not #{outer_type.class} (#{outer_type})"
+          end
+        }
+
+        SCHEMA_CAN_RESOLVE_TYPES = ->(schema) {
+          if schema.types.values.any? { |type| type.kind.abstract? } && schema.resolve_type_proc.nil?
+            "schema contains Interfaces or Unions, so you must define a `resolve_type -> (obj, ctx) { ... }` function"
+          else
+            # :+1:
+          end
+        }
+
+        SCHEMA_CAN_FETCH_IDS = ->(schema) {
+          has_node_field = schema.query && schema.query.fields.each_value.any?(&:relay_node_field)
+          if has_node_field && schema.object_from_id_proc.nil?
+            "schema contains `node(id:...)` field, so you must define a `object_from_id -> (id, ctx) { ... }` function"
+          else
+            # :rocket:
+          end
+        }
+
+        SCHEMA_CAN_GENERATE_IDS = ->(schema) {
+          has_id_field = schema.types.values.any? { |t| t.kind.fields? && t.all_fields.any? { |f| f.resolve_proc.is_a?(GraphQL::Relay::GlobalIdResolve) } }
+          if has_id_field && schema.id_from_object_proc.nil?
+            "schema contains `global_id_field`, so you must define a `id_from_object -> (obj, type, ctx) { ... }` function"
+          else
+            # :ok_hand:
+          end
+        }
+
+        SCHEMA_INSTRUMENTERS_ARE_VALID = ->(schema) {
+          errs = []
+          schema.instrumenters[:query].each do |inst|
+            if !inst.respond_to?(:before_query) || !inst.respond_to?(:after_query)
+              errs << "`instrument(:query, #{inst})` is invalid: must respond to `before_query(query)` and `after_query(query)` "
+            end
+          end
+
+          schema.instrumenters[:field].each do |inst|
+            if !inst.respond_to?(:instrument)
+              errs << "`instrument(:field, #{inst})` is invalid: must respond to `instrument(type, field)`"
+            end
+          end
+
+          if errs.any?
+            errs.join("Invalid instrumenters:\n" + errs.join("\n"))
+          else
+            nil
+          end
+        }
+
+        RESERVED_TYPE_NAME = ->(type) {
+          if type.name.start_with?('__') && !type.introspection?
+            # TODO: make this a hard failure in a later version
+            GraphQL::Deprecation.warn("Name #{type.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
+            nil
+          else
+            # ok name
+          end
+        }
+
+        RESERVED_NAME = ->(named_thing) {
+          if named_thing.name.start_with?('__')
+            # TODO: make this a hard failure in a later version
+            GraphQL::Deprecation.warn("Name #{named_thing.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
+            nil
+          else
+            # no worries
+          end
+        }
+
+        INTERFACES_ARE_IMPLEMENTED = ->(obj_type) {
+          field_errors = []
+          obj_type.interfaces.each do |interface_type|
+            interface_type.fields.each do |field_name, field_defn|
+              object_field = obj_type.get_field(field_name)
+              if object_field.nil?
+                field_errors << %|"#{field_name}" is required by #{interface_type.name} but not implemented by #{obj_type.name}|
+              elsif !GraphQL::Execution::Typecast.subtype?(field_defn.type, object_field.type)
+                field_errors << %|"#{field_name}" is required by #{interface_type.name} to return #{field_defn.type} but #{obj_type.name}.#{field_name} returns #{object_field.type}|
+              else
+                field_defn.arguments.each do |arg_name, arg_defn|
+                  object_field_arg = object_field.arguments[arg_name]
+                  if object_field_arg.nil?
+                    field_errors << %|"#{arg_name}" argument is required by #{interface_type.name}.#{field_name} but not accepted by #{obj_type.name}.#{field_name}|
+                  elsif arg_defn.type != object_field_arg.type
+                    field_errors << %|"#{arg_name}" is required by #{interface_type.name}.#{field_defn.name} to accept #{arg_defn.type} but #{obj_type.name}.#{field_name} accepts #{object_field_arg.type} for "#{arg_name}"|
+                  end
+                end
+
+                object_field.arguments.each do |arg_name, arg_defn|
+                  if field_defn.arguments[arg_name].nil? && arg_defn.type.is_a?(GraphQL::NonNullType)
+                    field_errors << %|"#{arg_name}" is not accepted by #{interface_type.name}.#{field_name} but required by #{obj_type.name}.#{field_name}|
+                  end
+                end
+              end
+            end
+          end
+          if field_errors.any?
+            "#{obj_type.name} failed to implement some interfaces: #{field_errors.join(", ")}"
+          else
+            nil
+          end
+        }
+      end
+
+      # A mapping of `{Class => [Proc, Proc...]}` pairs.
+      # To validate an instance, find entries where `object.is_a?(key)` is true.
+      # Then apply each rule from the matching values.
+      RULES = {
+        GraphQL::Field => [
+          Rules::NAME_IS_STRING,
+          Rules::RESERVED_NAME,
+          Rules::DESCRIPTION_IS_STRING_OR_NIL,
+          Rules.assert_property(:deprecation_reason, String, NilClass),
+          Rules.assert_property(:type, GraphQL::BaseType, GraphQL::Schema::LateBoundType),
+          Rules.assert_property(:property, Symbol, NilClass),
+          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
+          Rules::ARGUMENTS_ARE_VALID,
+        ],
+        GraphQL::Argument => [
+          Rules::NAME_IS_STRING,
+          Rules::RESERVED_NAME,
+          Rules::DESCRIPTION_IS_STRING_OR_NIL,
+          Rules.assert_property(:deprecation_reason, String, NilClass),
+          Rules::TYPE_IS_VALID_INPUT_TYPE,
+          Rules::DEFAULT_VALUE_IS_VALID_FOR_TYPE,
+          Rules::DEPRECATED_ARGUMENTS_ARE_OPTIONAL,
+        ],
+        GraphQL::BaseType => [
+          Rules::NAME_IS_STRING,
+          Rules::RESERVED_TYPE_NAME,
+          Rules::DESCRIPTION_IS_STRING_OR_NIL,
+        ],
+        GraphQL::ObjectType => [
+          Rules::HAS_AT_LEAST_ONE_FIELD,
+          Rules.assert_property_list_of(:interfaces, GraphQL::InterfaceType),
+          Rules::FIELDS_ARE_VALID,
+          Rules::INTERFACES_ARE_IMPLEMENTED,
+        ],
+        GraphQL::InputObjectType => [
+          Rules::HAS_AT_LEAST_ONE_ARGUMENT,
+          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
+          Rules::ARGUMENTS_ARE_VALID,
+        ],
+        GraphQL::UnionType => [
+          Rules.assert_property_list_of(:possible_types, GraphQL::ObjectType),
+          Rules::HAS_ONE_OR_MORE_POSSIBLE_TYPES,
+        ],
+        GraphQL::InterfaceType => [
+          Rules::FIELDS_ARE_VALID,
+        ],
+        GraphQL::Schema => [
+          Rules::SCHEMA_INSTRUMENTERS_ARE_VALID,
+          Rules::SCHEMA_CAN_RESOLVE_TYPES,
+          Rules::SCHEMA_CAN_FETCH_IDS,
+          Rules::SCHEMA_CAN_GENERATE_IDS,
+        ],
+      }
+    end
+  end
+end

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