graphql 1.10.2 → 2.0.21

data/lib/graphql/schema/timeout.rb

@@ -7,7 +7,7 @@ module GraphQL
     # to the `errors` key. Any already-resolved fields will be in the `data` key, so
     # you'll get a partial response.
     #
-    # You can subclass `GraphQL::Schema::Timeout` and override the `handle_timeout` method
+    # You can subclass `GraphQL::Schema::Timeout` and override `max_seconds` and/or `handle_timeout`
     # to provide custom logic when a timeout error occurs.
     #
     # Note that this will stop a query _in between_ field resolutions, but
@@ -33,58 +33,68 @@ module GraphQL
     #   end
     #
     class Timeout
-      attr_reader :max_seconds
-
-      def self.use(schema, **options)
-        tracer = new(**options)
-        schema.tracer(tracer)
+      def self.use(schema, max_seconds: nil)
+        timeout = self.new(max_seconds: max_seconds)
+        schema.trace_with(self::Trace, timeout: timeout)
       end
 
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:)
         @max_seconds = max_seconds
       end
 
-      def trace(key, data)
-        case key
-        when 'execute_multiplex'
-          timeout_state = {
-            timeout_at: Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) + max_seconds * 1000,
-            timed_out: false
-          }
-
-          data.fetch(:multiplex).queries.each do |query|
-            query.context.namespace(self.class)[:state] = timeout_state
-          end
+      module Trace
+        # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+        def initialize(timeout:, **rest)
+          @timeout = timeout
+          super
+        end
 
-          yield
-        when 'execute_field', 'execute_field_lazy'
-          query = data[:context] ? data.fetch(:context).query : data.fetch(:query)
-          timeout_state = query.context.namespace(self.class).fetch(:state)
-          if Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
-            error = if data[:context]
-              context = data.fetch(:context)
-              GraphQL::Schema::Timeout::TimeoutError.new(context.parent_type, context.field)
+        def execute_multiplex(multiplex:)
+          multiplex.queries.each do |query|
+            timeout_duration_s = @timeout.max_seconds(query)
+            timeout_state = if timeout_duration_s == false
+              # if the method returns `false`, don't apply a timeout
+              false
             else
-              field = data.fetch(:field)
-              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
+              now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+              timeout_at = now + (timeout_duration_s * 1000)
+              {
+                timeout_at: timeout_at,
+                timed_out: false
+              }
             end
+            query.context.namespace(@timeout)[:state] = timeout_state
+          end
+          super
+        end
 
+        def execute_field(query:, field:, **_rest)
+          timeout_state = query.context.namespace(@timeout).fetch(:state)
+          # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
+          if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+            error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
-            unless timeout_state[:timed_out]
+            if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
-              handle_timeout(error, query)
+              @timeout.handle_timeout(error, query)
             end
 
             error
           else
-            yield
+            super
           end
-        else
-          yield
         end
       end
 
+      # Called at the start of each query.
+      # The default implementation returns the `max_seconds:` value from installing this plugin.
+      #
+      # @param query [GraphQL::Query] The query that's about to run
+      # @return [Integer, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      def max_seconds(query)
+        @max_seconds
+      end
+
       # Invoked when a query times out.
       # @param error [GraphQL::Schema::Timeout::TimeoutError]
       # @param query [GraphQL::Error]
@@ -100,8 +110,8 @@ module GraphQL
       # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
       # such as `RuntimeError`.
       class TimeoutError < GraphQL::ExecutionError
-        def initialize(parent_type, field)
-          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        def initialize(field)
+          super("Timeout on #{field.path}")
         end
       end
     end

data/lib/graphql/schema/type_expression.rb

@@ -11,7 +11,7 @@ module GraphQL
       def self.build_type(type_owner, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName
-          type_owner.get_type(ast_node.name)
+          type_owner.get_type(ast_node.name) # rubocop:disable Development/ContextIsPassedCop -- this is a `context` or `warden`, it's already query-aware
         when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
           inner_type = build_type(type_owner, ast_inner_type)

data/lib/graphql/schema/type_membership.rb

@@ -4,8 +4,6 @@ module GraphQL
   class Schema
     # This class joins an object type to an abstract type (interface or union) of which
     # it is a member.
-    #
-    # TODO: Not yet implemented for interfaces.
     class TypeMembership
       # @return [Class<GraphQL::Schema::Object>]
       attr_accessor :object_type
@@ -13,6 +11,9 @@ module GraphQL
       # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
       attr_reader :abstract_type
 
+      # @return [Hash]
+      attr_reader :options
+
       # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
       # or {Schema::Object.implements} (for interfaces).
       #
@@ -26,9 +27,25 @@ module GraphQL
       end
 
       # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
-      def visible?(_ctx)
-        true
+      def visible?(ctx)
+        warden = Warden.from_context(ctx)
+        (@object_type.respond_to?(:visible?) ? warden.visible_type?(@object_type, ctx) : true) &&
+          (@abstract_type.respond_to?(:visible?) ? warden.visible_type?(@abstract_type, ctx) : true)
+      end
+
+      def graphql_name
+        "#{@object_type.graphql_name}.#{@abstract_type.kind.interface? ? "implements" : "belongsTo" }.#{@abstract_type.graphql_name}"
+      end
+
+      def path
+        graphql_name
+      end
+
+      def inspect
+        "#<#{self.class} #{@object_type.inspect} => #{@abstract_type.inspect}>"
       end
+
+      alias :type_class :itself
     end
   end
 end

data/lib/graphql/schema/union.rb

@@ -2,18 +2,25 @@
 module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasUnresolvedTypeError
 
       class << self
+        def inherited(child_class)
+          add_unresolved_type_error(child_class)
+          super
+        end
+
         def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
             types.each do |t|
+              assert_valid_union_member(t)
               type_memberships << type_membership_class.new(self, t, **options)
             end
           else
             visible_types = []
+            warden = Warden.from_context(context)
             type_memberships.each do |type_membership|
-              if type_membership.visible?(context)
+              if warden.visible_type_membership?(type_membership, context)
                 visible_types << type_membership.object_type
               end
             end
@@ -21,17 +28,8 @@ module GraphQL
           end
         end
 
-        def to_graphql
-          type_defn = GraphQL::UnionType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.ast_node = ast_node
-          type_defn.type_memberships = type_memberships
-          if respond_to?(:resolve_type)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn.metadata[:type_class] = self
-          type_defn
+        def all_possible_types
+          type_memberships.map(&:object_type)
         end
 
         def type_membership_class(membership_class = nil)
@@ -49,6 +47,43 @@ module GraphQL
         def type_memberships
           @type_memberships ||= []
         end
+
+        # Update a type membership whose `.object_type` is a string or late-bound type
+        # so that the type membership's `.object_type` is the given `object_type`.
+        # (This is used for updating the union after the schema as lazily loaded the union member.)
+        # @api private
+        def assign_type_membership_object_type(object_type)
+          assert_valid_union_member(object_type)
+          type_memberships.each { |tm|
+            possible_type = tm.object_type
+            if possible_type.is_a?(String) && (possible_type == object_type.name)
+              # This is a match of Ruby class names, not graphql names,
+              # since strings are used to refer to constants.
+              tm.object_type = object_type
+            elsif possible_type.is_a?(LateBoundType) && possible_type.graphql_name == object_type.graphql_name
+              tm.object_type = object_type
+            end
+          }
+          nil
+        end
+
+        private
+
+        def assert_valid_union_member(type_defn)
+          case type_defn
+          when Class
+            if !type_defn.kind.object?
+              raise ArgumentError, "Union possible_types can only be object types (not #{type_defn.kind.name}, #{type_defn.inspect})"
+            end
+          when Module
+            # it's an interface type, defined as a module
+            raise ArgumentError, "Union possible_types can only be object types (not interface types), remove #{type_defn.graphql_name} (#{type_defn.inspect})"
+          when String, GraphQL::Schema::LateBoundType
+            # Ok - assume it will get checked later
+          else
+            raise ArgumentError, "Union possible_types can only be class-based GraphQL types (not #{type_defn.inspect} (#{type_defn.class.name}))."
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/unique_within_type.rb

@@ -27,8 +27,7 @@ module GraphQL
       # @param node_id [String] A unique ID generated by {.encode}
       # @return [Array<(String, String)>] The type name & value passed to {.encode}
       def decode(node_id, separator: self.default_id_separator)
-        # urlsafe_decode64 is for forward compatibility
-        Base64Bp.urlsafe_decode64(node_id).split(separator, 2)
+        GraphQL::Schema::Base64Encoder.decode(node_id).split(separator, 2)
       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

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