graphql 1.8.0 → 1.12.12

data/lib/graphql/schema/traversal.rb

@@ -16,13 +16,24 @@ module GraphQL
       # @return [Hash<String => Array<GraphQL::BaseType>]
       attr_reader :union_memberships
 
+
       # @param schema [GraphQL::Schema]
       def initialize(schema, introspection: true)
         @schema = schema
         @introspection = introspection
+        built_in_insts = [
+          GraphQL::Relay::ConnectionInstrumentation,
+          GraphQL::Relay::EdgesInstrumentation,
+          GraphQL::Relay::Mutation::Instrumentation,
+        ]
+
+        if schema.query_execution_strategy != GraphQL::Execution::Interpreter
+          built_in_insts << GraphQL::Schema::Member::Instrumentation
+        end
+
         @field_instrumenters =
           schema.instrumenters[:field] +
-            Schema::BUILT_IN_INSTRUMENTERS +
+            built_in_insts +
             schema.instrumenters[:field_after_built_ins]
 
         # These fields have types specified by _name_,
@@ -102,7 +113,7 @@ Some late-bound types couldn't be resolved:
           # Find the starting points, then visit them
           visit_roots = [member.query, member.mutation, member.subscription]
           if @introspection
-            introspection_types = schema.introspection_system.object_types
+            introspection_types = schema.introspection_system.types.values
             visit_roots.concat(introspection_types)
             if member.query
               member.introspection_system.entry_points.each do |introspection_field|
@@ -158,7 +169,7 @@ Some late-bound types couldn't be resolved:
             end
           elsif !prev_type.equal?(type_defn)
             # If the previous entry in the map isn't the same object we just found, raise.
-            raise("Duplicate type definition found for name '#{type_defn.name}' (#{prev_type.metadata[:type_class]}, #{type_defn.metadata[:type_class]}})")
+            raise("Duplicate type definition found for name '#{type_defn.name}' at '#{context_description}' (#{prev_type.metadata[:type_class] || prev_type}, #{type_defn.metadata[:type_class] || type_defn})")
           end
         when Class
           if member.respond_to?(:graphql_definition)

data/lib/graphql/schema/type_expression.rb

@@ -5,29 +5,37 @@ module GraphQL
     module TypeExpression
       # Fetch a type from a type map by its AST specification.
       # Return `nil` if not found.
-      # @param types [GraphQL::Schema::TypeMap]
+      # @param type_owner [#get_type] A thing for looking up types by name
       # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
-      # @return [GraphQL::BaseType, nil]
-      def self.build_type(types, ast_node)
+      # @return [Class, GraphQL::Schema::NonNull, GraphQL::Schema:List]
+      def self.build_type(type_owner, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName
-          types.fetch(ast_node.name, nil)
+          type_owner.get_type(ast_node.name)
         when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
-          inner_type = build_type(types, ast_inner_type)
-          wrap_type(inner_type, GraphQL::NonNullType)
+          inner_type = build_type(type_owner, ast_inner_type)
+          wrap_type(inner_type, :to_non_null_type)
         when GraphQL::Language::Nodes::ListType
           ast_inner_type = ast_node.of_type
-          inner_type = build_type(types, ast_inner_type)
-          wrap_type(inner_type, GraphQL::ListType)
+          inner_type = build_type(type_owner, ast_inner_type)
+          wrap_type(inner_type, :to_list_type)
+        else
+          raise "Invariant: unexpected type from ast: #{ast_node.inspect}"
         end
       end
 
-      def self.wrap_type(type, wrapper)
-        if type.nil?
-          nil
-        else
-          wrapper.new(of_type: type)
+      class << self
+        private
+
+        def wrap_type(type, wrapper_method)
+          if type.nil?
+            nil
+          elsif wrapper_method == :to_list_type || wrapper_method == :to_non_null_type
+            type.public_send(wrapper_method)
+          else
+            raise ArgumentError, "Unexpected wrapper method: #{wrapper_method.inspect}"
+          end
         end
       end
     end

data/lib/graphql/schema/type_membership.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+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
+
+      # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      attr_reader :abstract_type
+
+      # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
+      # or {Schema::Object.implements} (for interfaces).
+      #
+      # @param abstract_type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param object_type [Class<GraphQL::Schema::Object>]
+      # @param options [Hash] Any options passed to `.possible_types` or `.implements`
+      def initialize(abstract_type, object_type, **options)
+        @abstract_type = abstract_type
+        @object_type = object_type
+        @options = options
+      end
+
+      # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
+      def visible?(_ctx)
+        true
+      end
+    end
+  end
+end

data/lib/graphql/schema/union.rb

@@ -3,15 +3,28 @@ module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasUnresolvedTypeError
 
       class << self
-        def possible_types(*types)
+        def inherited(child_class)
+          add_unresolved_type_error(child_class)
+          super
+        end
+
+        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
-            @possible_types = types
+            types.each do |t|
+              assert_valid_union_member(t)
+              type_memberships << type_membership_class.new(self, t, **options)
+            end
           else
-            all_possible_types = @possible_types || []
-            all_possible_types += super if defined?(super)
-            all_possible_types.uniq
+            visible_types = []
+            type_memberships.each do |type_membership|
+              if type_membership.visible?(context)
+                visible_types << type_membership.object_type
+              end
+            end
+            visible_types
           end
         end
 
@@ -19,7 +32,8 @@ module GraphQL
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name
           type_defn.description = description
-          type_defn.possible_types = possible_types
+          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
@@ -27,9 +41,49 @@ module GraphQL
           type_defn
         end
 
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
+          end
+        end
+
         def kind
           GraphQL::TypeKinds::UNION
         end
+
+        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)
+          if type_defn.is_a?(Module) && !type_defn.is_a?(Class)
+            # 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})"
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/unique_within_type.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'graphql/schema/base_64_bp'
+
 module GraphQL
   class Schema
     module UniqueWithinType
@@ -25,7 +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)
-        Base64.decode64(node_id).split(separator, 2)
+        GraphQL::Schema::Base64Encoder.decode(node_id).split(separator, 2)
       end
     end
   end

data/lib/graphql/schema/validation.rb

@@ -6,17 +6,24 @@ 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`
       # @param object [Object] something to be validated
       # @return [String, Nil] error message, if there was one
       def self.validate(object)
-        rules = RULES.reduce([]) do |memo, (parent_class, validations)|
-          memo + (object.is_a?(parent_class) ? validations : [])
+        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
-        # Stops after the first error
-        rules.reduce(nil) { |memo, rule| memo || rule.call(object) }
+        nil
       end
 
       module Rules
@@ -72,6 +79,18 @@ module GraphQL
           }
         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)
@@ -87,7 +106,9 @@ module GraphQL
           }
         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"
@@ -99,10 +120,6 @@ module GraphQL
         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? && type.type.is_a?(NonNullType)
-            return %Q(Variable #{type.name} of type "#{type.type}" is required and will not use the default value. Perhaps you meant to use type "#{type.type.of_type}".)
-          end
-
           if !type.default_value.nil?
             coerced_value = begin
               type.type.coerce_isolated_result(type.default_value)
@@ -118,9 +135,15 @@ module GraphQL
           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.is_a?(GraphQL::BaseType) ? outer_type.unwrap : nil
+          inner_type = outer_type.respond_to?(:unwrap) ? outer_type.unwrap : nil
 
           case inner_type
           when GraphQL::ScalarType, GraphQL::InputObjectType, GraphQL::EnumType
@@ -131,7 +154,7 @@ module GraphQL
         }
 
         SCHEMA_CAN_RESOLVE_TYPES = ->(schema) {
-          if schema.types.values.any? { |type| type.kind.resolves? } && schema.resolve_type_proc.nil?
+          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:
@@ -139,7 +162,7 @@ module GraphQL
         }
 
         SCHEMA_CAN_FETCH_IDS = ->(schema) {
-          has_node_field = schema.query && schema.query.all_fields.any?(&:relay_node_field)
+          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
@@ -180,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
@@ -190,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
@@ -250,8 +273,10 @@ module GraphQL
           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,
@@ -259,11 +284,13 @@ module GraphQL
           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,
         ],

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

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

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

@@ -0,0 +1,49 @@
+# 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
+        if !String.method_defined?(:match?)
+          using GraphQL::StringMatchBackport
+        end
+
+        # @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 (@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,33 @@
+# 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 !@in_list.include?(value)
+            @message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# 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)
+          if @maximum && value.length > @maximum
+            partial_format(@too_long, { count: @maximum })
+          elsif @minimum && value.length < @minimum
+            partial_format(@too_short, { count: @minimum })
+          elsif @is && value.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,71 @@
+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 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,
+            message: "%{validated} must be %{comparison} %{target}",
+            **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
+          @message = message
+          super(**default_options)
+        end
+
+        def validate(object, context, value)
+          if @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
+          end
+        end
+      end
+    end
+  end
+end