graphql 1.10.0.pre1 → 1.10.0.pre2

data/lib/graphql/schema/scalar.rb

@@ -3,11 +3,9 @@ module GraphQL
   class Schema
     class Scalar < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::ValidatesInput
 
       class << self
-        extend Forwardable
-        def_delegators :graphql_definition, :coerce_isolated_input, :coerce_isolated_result
-
         def coerce_input(val, ctx)
           val
         end
@@ -38,6 +36,23 @@ module GraphQL
           end
           @default_scalar
         end
+
+        def default_scalar?
+          @default_scalar ||= false
+        end
+
+        def validate_non_null_input(value, ctx)
+          result = Query::InputValidationResult.new
+          if coerce_input(value, ctx).nil?
+            str_value = if value == Float::INFINITY
+              ""
+            else
+              " #{GraphQL::Language.serialize(value)}"
+            end
+            result.add_problem("Could not coerce value#{str_value} to #{graphql_name}")
+          end
+          result
+        end
       end
     end
   end

data/lib/graphql/schema/subscription.rb

@@ -29,7 +29,7 @@ module GraphQL
       # propagate null.
       null false
 
-      def initialize(object:, context:)
+      def initialize(object:, context:, field:)
         super
         # Figure out whether this is an update or an initial subscription
         @mode = context.query.subscription_update? ? :update : :subscribe

data/lib/graphql/schema/timeout_middleware.rb

@@ -35,9 +35,10 @@ module GraphQL
 
       def call(parent_type, parent_object, field_definition, field_args, query_context)
         ns = query_context.namespace(self.class)
-        timeout_at = ns[:timeout_at] ||= Time.now + @max_seconds
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        timeout_at = ns[:timeout_at] ||= now + @max_seconds
 
-        if timeout_at < Time.now
+        if timeout_at < now
           on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
         else
           yield

data/lib/graphql/schema/traversal.rb

@@ -113,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|

data/lib/graphql/schema/type_expression.rb

@@ -5,38 +5,36 @@ 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)
-        t = type_from_ast(types, ast_node)
-        # maybe nil:
-        t ? t.graphql_definition : t
+      # @return [Class, GraphQL::Schema::NonNull, GraphQL::Schema:List]
+      def self.build_type(type_owner, ast_node)
+        case ast_node
+        when GraphQL::Language::Nodes::TypeName
+          type_owner.get_type(ast_node.name)
+        when GraphQL::Language::Nodes::NonNullType
+          ast_inner_type = ast_node.of_type
+          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(type_owner, ast_inner_type)
+          wrap_type(inner_type, :to_list_type)
+        else
+          raise "Invariant: unexpected type from ast: #{ast_node.inspect}"
+        end
       end
 
       class << self
         private
 
-        def type_from_ast(types, ast_node)
-          case ast_node
-          when GraphQL::Language::Nodes::TypeName
-            types.fetch(ast_node.name, nil)
-          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::Schema::NonNull)
-          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::Schema::List)
-          end
-        end
-
-        def wrap_type(of_type, wrapper)
-          if of_type.nil?
+        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
-            wrapper.new(of_type)
+            raise ArgumentError, "Unexpected wrapper method: #{wrapper_method.inspect}"
           end
         end
       end

data/lib/graphql/schema/validation.rb

@@ -77,6 +77,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)
@@ -92,7 +104,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"
@@ -140,7 +154,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
@@ -260,11 +274,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/warden.rb

@@ -39,19 +39,31 @@ module GraphQL
       # @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
         @visibility_cache = read_through { |m| filter.call(m, context) }
       end
 
       # @return [Array<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
@@ -81,7 +93,15 @@ 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).select { |t| visible_type?(t) } }
+        @visible_possible_types ||= if @schema.is_a?(Class)
+          all_possible_types = @schema.possible_types
+          read_through { |type_defn|
+            pt = all_possible_types[type_defn.graphql_name] || []
+            pt.select { |t| visible_type?(t) }
+          }
+        else
+          read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible_type?(t) } }
+        end
         @visible_possible_types[type_defn]
       end
 
@@ -136,28 +156,37 @@ module GraphQL
       end
 
       def visible_type?(type_defn)
-        return false unless visible?(type_defn)
-        return true if root_type?(type_defn)
-        return true if 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)
+        @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
@@ -170,7 +199,7 @@ module GraphQL
       end
 
       def visible_possible_types?(type_defn)
-        @schema.possible_types(type_defn).any? { |t| visible_type?(t) }
+        possible_types(type_defn).any? { |t| visible_type?(t) }
       end
 
       def visible?(member)

data/lib/graphql/schema/wrapper.rb

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

data/lib/graphql/static_validation/base_visitor.rb

@@ -71,7 +71,7 @@ module GraphQL
       module ContextMethods
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
-          @object_types.push(object_type)
+          push_type(object_type)
           @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
           super
           @object_types.pop
@@ -98,9 +98,9 @@ module GraphQL
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
-            @object_types.push(next_object_type)
+            push_type(next_object_type)
           else
-            @object_types.push(nil)
+            push_type(nil)
           end
           @path.push(node.alias || node.name)
           super
@@ -120,7 +120,7 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.input_fields[node.name]
+              arg_type.arguments[node.name]
             else
               nil
             end
@@ -187,15 +187,19 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.types.fetch(node.type.name, nil)
+            @schema.get_type(node.type.name)
           else
             @object_types.last
           end
-          @object_types.push(object_type)
+          push_type(object_type)
           yield(node)
           @object_types.pop
           @path.pop
         end
+
+        def push_type(t)
+          @object_types.push(t)
+        end
       end
 
       private

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -11,11 +11,11 @@ module GraphQL
         super
         @defdep_node_paths = {}
 
-        # { name => node } pairs for fragments
-        @defdep_fragment_definitions = {}
+        # { name => [node, ...] } pairs for fragments (although duplicate-named fragments are _invalid_, they are _possible_)
+        @defdep_fragment_definitions = Hash.new{ |h, k| h[k] = [] }
 
         # This tracks dependencies from fragment to Node where it was used
-        # { fragment_definition_node => [dependent_node, dependent_node]}
+        # { fragment_definition_name => [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] = NodeWithPath.new(node, context.path)
+        @defdep_node_paths[node.name] = 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[@defdep_fragment_definitions[node.name]] << @defdep_current_parent
+        @defdep_dependent_definitions[node.name] << @defdep_current_parent
         @defdep_immediate_dependencies[@defdep_current_parent] << node
         super
       end
@@ -116,24 +116,28 @@ 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 = @defdep_fragment_definitions.size
+        max_loops = 0
+        @defdep_fragment_definitions.each_value do |v|
+          max_loops += v.size
+        end
+
         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 - @defdep_immediate_dependencies.keys
+        independent_fragment_nodes = @defdep_fragment_definitions.values.flatten - @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.")
+            raise("Resolution loops exceeded the number of definitions; infinite loop detected. (Max: #{max_loops}, Current: #{loops})")
           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]
+          fragment_usages = @defdep_dependent_definitions[fragment_node.name]
           if fragment_usages.empty?
             # If we didn't record any usages during the visit,
             # then this fragment is unused.
@@ -151,10 +155,15 @@ module GraphQL
               if block_given?
                 yield(definition_node, removed, fragment_node)
               end
-              if remaining.empty? && definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+              if remaining.empty? &&
+                definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition) &&
+                definition_node.name != fragment_node.name
                 # 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
@@ -166,7 +175,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[spread.name].nil?
+            if !@defdep_fragment_definitions.key?(spread.name)
               dependency_map.unmet_dependencies[@defdep_node_paths[defn_node]] << @defdep_node_paths[spread]
               deps.delete(spread)
             end