graphql 1.8.0 → 1.12.12

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

@@ -0,0 +1,68 @@
+# 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: true
+      #     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
+      #
+      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:, message: "%{validated} has the wrong arguments", **default_options)
+          @one_of = one_of
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(_object, _context, value)
+          matched_conditions = 0
+
+          @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
+
+          if matched_conditions == 1
+            nil # OK
+          else
+            @message
+          end
+        end
+      end
+    end
+  end
+end

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)

data/lib/graphql/schema/warden.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'set'
+
 module GraphQL
   class Schema
     # Restrict access to a {GraphQL::Schema} with a user-defined filter.
@@ -37,21 +40,33 @@ module GraphQL
       # @param filter [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
-      # @param deep_check [Boolean]
       def initialize(filter, context:, schema:)
-        @schema = schema
+        @schema = schema.interpreter? ? schema : schema.graphql_definition
+        # Cache these to avoid repeated hits to the inheritance chain when one isn't present
+        @query = @schema.query
+        @mutation = @schema.mutation
+        @subscription = @schema.subscription
+        @context = context
         @visibility_cache = read_through { |m| filter.call(m, context) }
       end
 
-      # @return [Array<GraphQL::BaseType>] Visible types in the schema
+      # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
       def types
-        @types ||= @schema.types.each_value.select { |t| visible_type?(t) }
+        @types ||= begin
+          vis_types = {}
+          @schema.types.each do |n, t|
+            if visible_type?(t)
+              vis_types[n] = t
+            end
+          end
+          vis_types
+        end
       end
 
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
       def get_type(type_name)
         @visible_types ||= read_through do |name|
-          type_defn = @schema.types.fetch(name, nil)
+          type_defn = @schema.get_type(name)
           if type_defn && visible_type?(type_defn)
             type_defn
           else
@@ -62,13 +77,23 @@ module GraphQL
         @visible_types[type_name]
       end
 
+      # @return [Array<GraphQL::BaseType>] Visible and reachable types in the schema
+      def reachable_types
+        @reachable_types ||= reachable_type_set.to_a
+      end
+
+      # @return Boolean True if the type is visible and reachable in the schema
+      def reachable_type?(type_name)
+        type = get_type(type_name)
+        type && reachable_type_set.include?(type)
+      end
+
       # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`, if it exists
       def get_field(parent_type, field_name)
-
         @visible_parent_fields ||= read_through do |type|
           read_through do |f_name|
             field_defn = @schema.get_field(type, f_name)
-            if field_defn && visible_field?(field_defn)
+            if field_defn && visible_field?(type, field_defn)
               field_defn
             else
               nil
@@ -79,23 +104,32 @@ module GraphQL
         @visible_parent_fields[parent_type][field_name]
       end
 
+      # @return [GraphQL::Argument, nil] The argument named `argument_name` on `parent_type`, if it exists and is visible
+      def get_argument(parent_type, argument_name)
+        argument = parent_type.get_argument(argument_name)
+        return argument if argument && visible_argument?(argument)
+      end
+
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
-        @visible_possible_types ||= read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible_type?(t) } }
+        @visible_possible_types ||= read_through { |type_defn|
+          pt = @schema.possible_types(type_defn, @context)
+          pt.select { |t| visible_type?(t) }
+        }
         @visible_possible_types[type_defn]
       end
 
       # @param type_defn [GraphQL::ObjectType, GraphQL::InterfaceType]
       # @return [Array<GraphQL::Field>] Fields on `type_defn`
       def fields(type_defn)
-        @visible_fields ||= read_through { |t| @schema.get_fields(t).each_value.select { |f| visible_field?(f) } }
+        @visible_fields ||= read_through { |t| @schema.get_fields(t).each_value.select { |f| visible_field?(t, f) } }
         @visible_fields[type_defn]
       end
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
       def arguments(argument_owner)
-        @visible_arguments ||= read_through { |o| o.arguments.each_value.select { |a| visible_field?(a) } }
+        @visible_arguments ||= read_through { |o| o.arguments.each_value.select { |a| visible_argument?(a) } }
         @visible_arguments[argument_owner]
       end
 
@@ -107,7 +141,7 @@ module GraphQL
 
       # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
       def interfaces(obj_type)
-        @visible_interfaces ||= read_through { |t| t.interfaces.select { |i| visible?(i) } }
+        @visible_interfaces ||= read_through { |t| t.interfaces(@context).select { |i| visible?(i) } }
         @visible_interfaces[obj_type]
       end
 
@@ -131,29 +165,92 @@ module GraphQL
         @unions[obj_type]
       end
 
-      def visible_field?(field_defn)
-        visible?(field_defn) && visible_type?(field_defn.type.unwrap)
+      def visible_argument?(arg_defn)
+        visible?(arg_defn) && visible_type?(arg_defn.type.unwrap)
+      end
+
+      def visible_field?(owner_type, field_defn)
+        # This field is visible in its own right
+        visible?(field_defn) &&
+          # This field's return type is visible
+          visible_type?(field_defn.type.unwrap) &&
+          # This field is either defined on this object type,
+          # or the interface it's inherited from is also visible
+          ((field_defn.respond_to?(:owner) && field_defn.owner == owner_type) || field_on_visible_interface?(field_defn, owner_type))
+      end
+
+      # We need this to tell whether a field was inherited by an interface
+      # even when that interface is hidden from `#interfaces`
+      def unfiltered_interfaces(type_defn)
+        @unfiltered_interfaces ||= read_through(&:interfaces)
+        @unfiltered_interfaces[type_defn]
+      end
+
+      # If this field was inherited from an interface, and the field on that interface is _hidden_,
+      # then treat this inherited field as hidden.
+      # (If it _wasn't_ inherited, then don't hide it for this reason.)
+      def field_on_visible_interface?(field_defn, type_defn)
+        if type_defn.kind.object?
+          any_interface_has_field = false
+          any_interface_has_visible_field = false
+          ints = unfiltered_interfaces(type_defn)
+          ints.each do |interface_type|
+            if (iface_field_defn = interface_type.get_field(field_defn.graphql_name))
+              any_interface_has_field = true
+
+              if interfaces(type_defn).include?(interface_type) && visible_field?(interface_type, iface_field_defn)
+                any_interface_has_visible_field = true
+              end
+            end
+          end
+
+          if any_interface_has_field
+            any_interface_has_visible_field
+          else
+            # it's the object's own field
+            true
+          end
+        else
+          true
+        end
       end
 
       def visible_type?(type_defn)
-        visible?(type_defn) && (
-            root_type?(type_defn) ||
-            type_defn.introspection? ||
-            referenced?(type_defn) ||
-            visible_abstract_type?(type_defn) ||
-            possible_types?(type_defn)
-          )
+        @type_visibility ||= read_through do |type_defn|
+          next false unless visible?(type_defn)
+          next true if root_type?(type_defn) || type_defn.introspection?
+
+          if type_defn.kind.union?
+            visible_possible_types?(type_defn) && (referenced?(type_defn) || orphan_type?(type_defn))
+          elsif type_defn.kind.interface?
+            visible_possible_types?(type_defn)
+          else
+            referenced?(type_defn) || visible_abstract_type?(type_defn)
+          end
+        end
+
+        @type_visibility[type_defn]
       end
 
       def root_type?(type_defn)
-        @schema.root_types.include?(type_defn)
+        @query == type_defn ||
+          @mutation == type_defn ||
+          @subscription == type_defn
       end
 
       def referenced?(type_defn)
-        members = @schema.references_to(type_defn.unwrap.name)
+        @references_to ||= @schema.references_to
+        graphql_name = type_defn.unwrap.graphql_name
+        members = @references_to[graphql_name] || NO_REFERENCES
         members.any? { |m| visible?(m) }
       end
 
+      NO_REFERENCES = [].freeze
+
+      def orphan_type?(type_defn)
+        @schema.orphan_types.include?(type_defn)
+      end
+
       def visible_abstract_type?(type_defn)
         type_defn.kind.object? && (
             interfaces(type_defn).any? ||
@@ -161,9 +258,8 @@ module GraphQL
           )
       end
 
-      def possible_types?(type_defn)
-        (type_defn.kind.union? || type_defn.kind.interface?) &&
-          @schema.possible_types(type_defn).any? { |t| visible_type?(t) }
+      def visible_possible_types?(type_defn)
+        possible_types(type_defn).any? { |t| visible_type?(t) }
       end
 
       def visible?(member)
@@ -173,6 +269,77 @@ module GraphQL
       def read_through
         Hash.new { |h, k| h[k] = yield(k) }
       end
+
+      def reachable_type_set
+        return @reachable_type_set if defined?(@reachable_type_set)
+
+        @reachable_type_set = Set.new
+
+        unvisited_types = []
+        ['query', 'mutation', 'subscription'].each do |op_name|
+          root_type = root_type_for_operation(op_name)
+          unvisited_types << root_type if root_type
+        end
+        unvisited_types.concat(@schema.introspection_system.types.values)
+
+        directives.each do |dir_class|
+          dir_class.arguments.values.each do |arg_defn|
+            arg_t = arg_defn.type.unwrap
+            if get_type(arg_t.graphql_name)
+              unvisited_types << arg_t
+            end
+          end
+        end
+
+        @schema.orphan_types.each do |orphan_type|
+          if get_type(orphan_type.graphql_name)
+            unvisited_types << orphan_type
+          end
+        end
+
+        until unvisited_types.empty?
+          type = unvisited_types.pop
+          if @reachable_type_set.add?(type)
+            if type.kind.input_object?
+              # recurse into visible arguments
+              arguments(type).each do |argument|
+                argument_type = argument.type.unwrap
+                unvisited_types << argument_type
+              end
+            elsif type.kind.union?
+              # recurse into visible possible types
+              possible_types(type).each do |possible_type|
+                unvisited_types << possible_type
+              end
+            elsif type.kind.fields?
+              if type.kind.interface?
+                # recurse into visible possible types
+                possible_types(type).each do |possible_type|
+                  unvisited_types << possible_type
+                end
+              elsif type.kind.object?
+                # recurse into visible implemented interfaces
+                interfaces(type).each do |interface|
+                  unvisited_types << interface
+                end
+              end
+
+              # recurse into visible fields
+              fields(type).each do |field|
+                field_type = field.type.unwrap
+                unvisited_types << field_type
+                # recurse into visible arguments
+                arguments(field).each do |argument|
+                  argument_type = argument.type.unwrap
+                  unvisited_types << argument_type
+                end
+              end
+            end
+          end
+        end
+
+        @reachable_type_set
+      end
     end
   end
 end

data/lib/graphql/schema/wrapper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Wrapper
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::TypeSystemHelpers
+
+      # @return [Class, Module] The inner type of this wrapping type, the type of which one or more objects may be present.
+      attr_reader :of_type
+
+      def initialize(of_type)
+        @of_type = of_type
+      end
+
+      def to_graphql
+        raise GraphQL::RequiredImplementationMissingError
+      end
+
+      def unwrap
+        @of_type.unwrap
+      end
+
+      def ==(other)
+        self.class == other.class && of_type == other.of_type
+      end
+    end
+  end
+end