graphql 1.9.21 → 1.10.0.pre1

data/lib/graphql/schema/warden.rb

@@ -1,7 +1,4 @@
 # frozen_string_literal: true
-
-require 'set'
-
 module GraphQL
   class Schema
     # Restrict access to a {GraphQL::Schema} with a user-defined filter.
@@ -43,8 +40,7 @@ module GraphQL
       # @param deep_check [Boolean]
       def initialize(filter, context:, schema:)
         @schema = schema
-        @context = context
-        @visibility_cache = read_through { |m| filter.call(m, @context) }
+        @visibility_cache = read_through { |m| filter.call(m, context) }
       end
 
       # @return [Array<GraphQL::BaseType>] Visible types in the schema
@@ -66,17 +62,6 @@ 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)
 
@@ -96,7 +81,7 @@ module GraphQL
 
       # @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, @context).select { |t| visible_type?(t) } }
+        @visible_possible_types ||= read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible_type?(t) } }
         @visible_possible_types[type_defn]
       end
 
@@ -185,7 +170,7 @@ module GraphQL
       end
 
       def visible_possible_types?(type_defn)
-        @schema.possible_types(type_defn, @context).any? { |t| visible_type?(t) }
+        @schema.possible_types(type_defn).any? { |t| visible_type?(t) }
       end
 
       def visible?(member)
@@ -195,65 +180,6 @@ 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.object_types)
-        @schema.orphan_types.each do |orphan_type|
-          unvisited_types << orphan_type.graphql_definition if get_type(orphan_type.graphql_name)
-        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

@@ -14,7 +14,7 @@ module GraphQL
       end
 
       def to_graphql
-        raise GraphQL::RequiredImplementationMissingError
+        raise NotImplementedError
       end
 
       def unwrap

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -11,11 +11,11 @@ module GraphQL
         super
         @defdep_node_paths = {}
 
-        # { name => [node, ...] } pairs for fragments (although duplicate-named fragments are _invalid_, they are _possible_)
-        @defdep_fragment_definitions = Hash.new{ |h, k| h[k] = [] }
+        # { name => node } pairs for fragments
+        @defdep_fragment_definitions = {}
 
         # This tracks dependencies from fragment to Node where it was used
-        # { fragment_definition_name => [dependent_node, dependent_node]}
+        # { fragment_definition_node => [dependent_node, dependent_node]}
         @defdep_dependent_definitions = Hash.new { |h, k| h[k] = Set.new }
 
         # First-level usages of spreads within definitions
@@ -32,7 +32,7 @@ module GraphQL
       def on_document(node, parent)
         node.definitions.each do |definition|
           if definition.is_a? GraphQL::Language::Nodes::FragmentDefinition
-            @defdep_fragment_definitions[definition.name] << definition
+            @defdep_fragment_definitions[definition.name] = definition
           end
         end
         super
@@ -42,7 +42,7 @@ module GraphQL
       end
 
       def on_operation_definition(node, prev_node)
-        @defdep_node_paths[node.name] = NodeWithPath.new(node, context.path)
+        @defdep_node_paths[node] = NodeWithPath.new(node, context.path)
         @defdep_current_parent = node
         super
         @defdep_current_parent = nil
@@ -59,7 +59,7 @@ module GraphQL
         @defdep_node_paths[node] = NodeWithPath.new(node, context.path)
 
         # Track both sides of the dependency
-        @defdep_dependent_definitions[node.name] << @defdep_current_parent
+        @defdep_dependent_definitions[@defdep_fragment_definitions[node.name]] << @defdep_current_parent
         @defdep_immediate_dependencies[@defdep_current_parent] << node
         super
       end
@@ -116,28 +116,24 @@ module GraphQL
         dependency_map = DependencyMap.new
         # Don't allow the loop to run more times
         # than the number of fragments in the document
-        max_loops = 0
-        @defdep_fragment_definitions.each_value do |v|
-          max_loops += v.size
-        end
-
+        max_loops = @defdep_fragment_definitions.size
         loops = 0
 
         # Instead of tracking independent fragments _as you visit_,
         # determine them at the end. This way, we can treat fragments with the
         # same name as if they were the same name. If _any_ of the fragments
         # with that name has a dependency, we record it.
-        independent_fragment_nodes = @defdep_fragment_definitions.values.flatten - @defdep_immediate_dependencies.keys
+        independent_fragment_nodes = @defdep_fragment_definitions.values - @defdep_immediate_dependencies.keys
 
         while fragment_node = independent_fragment_nodes.pop
           loops += 1
           if loops > max_loops
-            raise("Resolution loops exceeded the number of definitions; infinite loop detected. (Max: #{max_loops}, Current: #{loops})")
+            raise("Resolution loops exceeded the number of definitions; infinite loop detected.")
           end
           # Since it's independent, let's remove it from here.
           # That way, we can use the remainder to identify cycles
           @defdep_immediate_dependencies.delete(fragment_node)
-          fragment_usages = @defdep_dependent_definitions[fragment_node.name]
+          fragment_usages = @defdep_dependent_definitions[fragment_node]
           if fragment_usages.empty?
             # If we didn't record any usages during the visit,
             # then this fragment is unused.
@@ -155,15 +151,10 @@ module GraphQL
               if block_given?
                 yield(definition_node, removed, fragment_node)
               end
-              if remaining.empty? &&
-                definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition) &&
-                definition_node.name != fragment_node.name
+              if remaining.empty? && definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
                 # If all of this definition's dependencies have
                 # been resolved, we can now resolve its
                 # own dependents.
-                #
-                # But, it's possible to have a duplicate-named fragment here.
-                # Skip it in that case
                 independent_fragment_nodes << definition_node
               end
             end
@@ -175,7 +166,7 @@ module GraphQL
         # then they're still in there
         @defdep_immediate_dependencies.each do |defn_node, deps|
           deps.each do |spread|
-            if !@defdep_fragment_definitions.key?(spread.name)
+            if @defdep_fragment_definitions[spread.name].nil?
               dependency_map.unmet_dependencies[@defdep_node_paths[defn_node]] << @defdep_node_paths[spread]
               deps.delete(spread)
             end

data/lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -11,7 +11,7 @@ module GraphQL
             nil
           else
             arg_ret_type = arg_defn.type.unwrap
-            if !arg_ret_type.is_a?(GraphQL::InputObjectType)
+            if !arg_ret_type.kind.input_object?
               nil
             else
               arg_ret_type
@@ -54,7 +54,7 @@ module GraphQL
                 node.value.arguments.include?(err.ast_value)
               else
                 # otherwise we just check equality
-                node.value == (err.ast_value)
+                node.value == err.ast_value
               end
               if !matched
                 # This node isn't the node that caused the error,
@@ -67,9 +67,14 @@ module GraphQL
               error ||= begin
                 kind_of_node = node_type(parent)
                 error_arg_name = parent_name(parent, parent_defn)
+                string_value = if node.value == Float::INFINITY
+                  ""
+                else
+                  " (#{GraphQL::Language::Printer.new.print(node.value)})"
+                end
 
                 GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
-                  "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.",
+                  "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value#{string_value}. Expected type '#{arg_defn.type.to_type_signature}'.",
                   nodes: parent,
                   type: kind_of_node,
                   argument: node.name
@@ -92,7 +97,7 @@ module GraphQL
         elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
           type_defn.name
         else
-          parent.name
+          parent.graphql_name
         end
       end
 

data/lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -10,10 +10,10 @@ module GraphQL
             nil
           else
             arg_ret_type = arg_defn.type.unwrap
-            if !arg_ret_type.is_a?(GraphQL::InputObjectType)
-              nil
-            else
+            if arg_ret_type.kind.input_object?
               arg_ret_type
+            else
+              nil
             end
           end
         when GraphQL::Language::Nodes::Directive
@@ -45,12 +45,15 @@ module GraphQL
       private
 
       def parent_name(parent, type_defn)
-        if parent.is_a?(GraphQL::Language::Nodes::Field)
+        case parent
+        when GraphQL::Language::Nodes::Field
           parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
+        when GraphQL::Language::Nodes::InputObject
+          type_defn.graphql_name
+        when GraphQL::Language::Nodes::Argument, GraphQL::Language::Nodes::Directive
           parent.name
+        else
+          raise "Invariant: Unexpected parent #{parent.inspect} (#{parent.class})"
         end
       end
 

data/lib/graphql/static_validation/rules/directives_are_in_valid_locations.rb

@@ -56,7 +56,7 @@ module GraphQL
             "'@#{directive_defn.graphql_name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})",
             nodes: directive_ast,
             target: location_name,
-            name: directive_defn.name
+            name: directive_defn.graphql_name
           ))
         end
       end

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -27,12 +27,12 @@ module GraphQL
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
           if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
           else
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
           end
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
-          "Field must have selections (%{node_name} returns #{resolved_type.name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
+          "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else
           nil
         end
@@ -55,13 +55,13 @@ module GraphQL
             "name": node_name.to_s
           }
           unless resolved_type.nil?
-            extensions["type"] = resolved_type.to_s
+            extensions["type"] = resolved_type.to_type_signature
           end
           add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
             msg % { node_name: node_name },
             nodes: ast_node,
             node_name: node_name.to_s,
-            type: resolved_type.nil? ? nil : resolved_type.to_s
+            type: resolved_type.nil? ? nil : resolved_type.graphql_name,
           ))
           false
         else

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -93,8 +93,8 @@ module GraphQL
 
         return if fragment1.nil? || fragment2.nil?
 
-        fragment_type1 = context.schema.types[fragment1.type.name]
-        fragment_type2 = context.schema.types[fragment2.type.name]
+        fragment_type1 = context.warden.get_type(fragment1.type.name)
+        fragment_type2 = context.warden.get_type(fragment2.type.name)
 
         return if fragment_type1.nil? || fragment_type2.nil?
 
@@ -146,7 +146,7 @@ module GraphQL
         fragment = context.fragments[fragment_name]
         return if fragment.nil?
 
-        fragment_type = context.schema.types[fragment.type.name]
+        fragment_type = context.warden.get_type(fragment.type.name)
         return if fragment_type.nil?
 
         fragment_fields, fragment_spreads = fields_and_fragments_from_selection(fragment, owner_type: fragment_type, parents: [*fragment_spread.parents, fragment_type])
@@ -316,7 +316,7 @@ module GraphQL
             definition = context.schema.get_field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
-            fragment_type = node.type ? context.schema.types[node.type.name] : owner_type
+            fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type
             find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)

data/lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb

@@ -46,10 +46,10 @@ module GraphQL
           path = [*context.path, missing_field]
           missing_field_type = parent_type.arguments[missing_field].type
           add_error(RequiredInputObjectAttributesArePresentError.new(
-            "Argument '#{missing_field}' on InputObject '#{parent_type}' is required. Expected type #{missing_field_type}",
+            "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,
-            argument_type: missing_field_type.to_s,
-            input_object_type: parent_type.to_s,
+            argument_type: missing_field_type.to_type_signature,
+            input_object_type: parent_type.to_type_signature,
             path: path,
             nodes: ast_node,
           ))

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -13,7 +13,7 @@ module GraphQL
               error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_ON_NON_NULL]
             ))
           else
-            type = context.schema.type_from_ast(node.type)
+            type = context.schema.type_from_ast(node.type, context: context)
             if type.nil?
               # This is handled by another validator
             else
@@ -26,13 +26,13 @@ module GraphQL
               end
 
               if !valid
-                error_message ||= "Default value for $#{node.name} doesn't match type #{type}"
+                error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
                 VariableDefaultValuesAreCorrectlyTypedError
                 add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
                   error_message,
                   nodes: node,
                   name: node.name,
-                  type: type.to_s,
+                  type: type.to_type_signature,
                   error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE]
                 ))
               end

data/lib/graphql/static_validation/rules/variable_usages_are_allowed.rb

@@ -52,17 +52,16 @@ module GraphQL
       private
 
       def validate_usage(arguments, arg_node, ast_var)
-        var_type = context.schema.type_from_ast(ast_var.type)
+        var_type = context.schema.type_from_ast(ast_var.type, context: context)
         if var_type.nil?
           return
         end
         if !ast_var.default_value.nil?
-          unless var_type.is_a?(GraphQL::NonNullType)
+          unless var_type.kind.non_null?
             # If the value is required, but the argument is not,
             # and yet there's a non-nil default, then we impliclty
             # make the argument also a required type.
-
-            var_type = GraphQL::NonNullType.new(of_type: var_type)
+            var_type = var_type.to_non_null_type
           end
         end
 
@@ -85,10 +84,10 @@ module GraphQL
 
       def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
         add_error(GraphQL::StaticValidation::VariableUsagesAreAllowedError.new(
-          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})",
+          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_type_signature} / #{arg_defn.type.to_type_signature})",
           nodes: arg_node,
           name: ast_var.name,
-          type: var_type.to_s,
+          type: var_type.to_type_signature,
           argument: arg_node.name,
           error: error_message
         ))

data/lib/graphql/static_validation/rules/variables_are_input_types.rb

@@ -15,7 +15,7 @@ module GraphQL
           ))
         elsif !type.kind.input?
           add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
-            "#{type.name} isn't a valid input type (on $#{node.name})",
+            "#{type.graphql_name} isn't a valid input type (on $#{node.name})",
             nodes: node,
             name: node.name,
             type: type_name