graphql 1.4.5 → 1.5.3

data/lib/graphql/schema/default_parse_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module DefaultParseError
+      def self.call(parse_error, ctx)
+        ctx.errors.push(parse_error)
+      end
+    end
+  end
+end

data/lib/graphql/schema/loader.rb

@@ -107,7 +107,14 @@ module GraphQL
             )
           when "ARGUMENT"
             kwargs = {}
-            kwargs[:default_value] = JSON.parse(type["defaultValue"], quirks_mode: true) if type["defaultValue"]
+            if type["defaultValue"]
+              kwargs[:default_value] = begin
+                JSON.parse(type["defaultValue"], quirks_mode: true)
+              rescue JSON::ParserError
+                # Enum values are not valid JSON, they're bare identifiers
+                type["default_value"]
+              end
+            end
 
             Argument.define(
               name: type["name"],

data/lib/graphql/schema/null_mask.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Schema
     # @api private

data/lib/graphql/schema/validation.rb

@@ -196,6 +196,40 @@ module GraphQL
             # no worries
           end
         }
+
+        INTERFACES_ARE_IMPLEMENTED = ->(obj_type) {
+          field_errors = []
+          obj_type.interfaces.each do |interface_type|
+            interface_type.fields.each do |field_name, field_defn|
+              object_field = obj_type.get_field(field_name)
+              if object_field.nil?
+                field_errors << %|"#{field_name}" is required by #{interface_type.name} but not implemented by #{obj_type.name}|
+              elsif !GraphQL::Execution::Typecast.subtype?(field_defn.type, object_field.type)
+                field_errors << %|"#{field_name}" is required by #{interface_type.name} to return #{field_defn.type} but #{obj_type.name}.#{field_name} returns #{object_field.type}|
+              else
+                field_defn.arguments.each do |arg_name, arg_defn|
+                  object_field_arg = object_field.arguments[arg_name]
+                  if object_field_arg.nil?
+                    field_errors << %|"#{arg_name}" argument is required by #{interface_type.name}.#{field_name} but not accepted by #{obj_type.name}.#{field_name}|
+                  elsif arg_defn.type != object_field_arg.type
+                    field_errors << %|"#{arg_name}" is required by #{interface_type.name}.#{field_defn.name} to accept #{arg_defn.type} but #{obj_type.name}.#{field_name} accepts #{object_field_arg.type} for "#{arg_name}"|
+                  end
+                end
+
+                object_field.arguments.each do |arg_name, arg_defn|
+                  if field_defn.arguments[arg_name].nil? && arg_defn.type.is_a?(GraphQL::NonNullType)
+                    field_errors << %|"#{arg_name}" is not accepted by #{interface_type.name}.#{field_name} but required by #{obj_type.name}.#{field_name}|
+                  end
+                end
+              end
+            end
+          end
+          if field_errors.any?
+            "#{obj_type.name} failed to implement some interfaces: #{field_errors.join(", ")}"
+          else
+            nil
+          end
+        }
       end
 
       # A mapping of `{Class => [Proc, Proc...]}` pairs.
@@ -227,6 +261,7 @@ module GraphQL
         GraphQL::ObjectType => [
           Rules.assert_property_list_of(:interfaces, GraphQL::InterfaceType),
           Rules::FIELDS_ARE_VALID,
+          Rules::INTERFACES_ARE_IMPLEMENTED,
         ],
         GraphQL::InputObjectType => [
           Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,

data/lib/graphql/static_validation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/static_validation/message"
 require "graphql/static_validation/arguments_validator"
+require "graphql/static_validation/definition_dependencies"
 require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"

data/lib/graphql/static_validation/all_rules.rb

@@ -12,6 +12,7 @@ module GraphQL
       GraphQL::StaticValidation::UniqueDirectivesPerLocation,
       GraphQL::StaticValidation::FragmentsAreFinite,
       GraphQL::StaticValidation::FragmentsAreNamed,
+      GraphQL::StaticValidation::FragmentNamesAreUnique,
       GraphQL::StaticValidation::FragmentsAreUsed,
       GraphQL::StaticValidation::FragmentTypesExist,
       GraphQL::StaticValidation::FragmentsAreOnCompositeTypes,

data/lib/graphql/static_validation/arguments_validator.rb

@@ -8,20 +8,23 @@ module GraphQL
       def validate(context)
         visitor = context.visitor
         visitor[GraphQL::Language::Nodes::Argument] << ->(node, parent) {
-          if parent.is_a?(GraphQL::Language::Nodes::InputObject)
+          case parent
+          when GraphQL::Language::Nodes::InputObject
             arg_defn = context.argument_definition
             if arg_defn.nil?
               return
             else
               parent_defn = arg_defn.type.unwrap
-              if parent_defn.is_a?(GraphQL::ScalarType)
+              if !parent_defn.is_a?(GraphQL::InputObjectType)
                 return
               end
             end
-          elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
+          when GraphQL::Language::Nodes::Directive
             parent_defn = context.schema.directives[parent.name]
-          else
+          when GraphQL::Language::Nodes::Field
             parent_defn = context.field_definition
+          else
+            raise "Unexpected argument parent: #{parent.class} (##{parent})"
           end
           validate_node(parent, node, parent_defn, context)
         }

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    # Track fragment dependencies for operations
+    # and expose the fragment definitions which
+    # are used by a given operation
+    class DefinitionDependencies
+      def self.mount(visitor)
+        deps = self.new
+        deps.mount(visitor)
+        deps
+      end
+
+      def initialize
+        # { name => node } pairs for fragments
+        @fragment_definitions = {}
+
+        # This tracks dependencies from fragment to Node where it was used
+        # { frag_name => [dependent_node, dependent_node]}
+        @dependent_definitions = Hash.new { |h, k| h[k] = Set.new }
+
+        # First-level usages of spreads within definitions
+        # (When a key has an empty list as its value,
+        #  we can resolve that key's depenedents)
+        # { string => [node, node ...] }
+        @immediate_dependencies = Hash.new { |h, k| h[k] = Set.new }
+      end
+
+      # A map of operation definitions to an array of that operation's dependencies
+      # @return [DependencyMap]
+      def dependency_map(&block)
+        @dependency_map ||= resolve_dependencies(&block)
+      end
+
+
+      def mount(context)
+        visitor = context.visitor
+        # When we encounter a spread,
+        # this node is the one who depends on it
+        current_parent = nil
+
+        visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, prev_node) {
+          current_parent = NodeWithPath.new(node, context.path)
+        }
+
+        visitor[GraphQL::Language::Nodes::OperationDefinition].leave << ->(node, prev_node) {
+          current_parent = nil
+        }
+
+        visitor[GraphQL::Language::Nodes::FragmentDefinition] << ->(node, prev_node) {
+          current_parent = @fragment_definitions[node.name] = NodeWithPath.new(node, context.path)
+        }
+
+        visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << ->(node, prev_node) {
+          current_parent = nil
+        }
+
+        visitor[GraphQL::Language::Nodes::FragmentSpread] << ->(node, prev_node) {
+          # Track both sides of the dependency
+          @dependent_definitions[node.name] << current_parent
+          @immediate_dependencies[current_parent.name] << NodeWithPath.new(node, context.path)
+        }
+      end
+
+      # Map definition AST nodes to the definition AST nodes they depend on.
+      # Expose circular depednencies.
+      class DependencyMap
+        # @return [Array<GraphQL::Language::Nodes::FragmentDefinition>]
+        attr_reader :cyclical_definitions
+
+        # @return [Hash<Node, Array<GraphQL::Language::Nodes::FragmentSpread>>]
+        attr_reader :unmet_dependencies
+
+        # @return [Array<GraphQL::Language::Nodes::FragmentDefinition>]
+        attr_reader :unused_dependencies
+
+        def initialize
+          @dependencies = Hash.new { |h, k| h[k] = [] }
+          @cyclical_definitions = []
+          @unmet_dependencies = Hash.new { |h, k| h[k] = [] }
+          @unused_dependencies = []
+        end
+
+        # @return [Array<GraphQL::Language::Nodes::AbstractNode>] dependencies for `definition_node`
+        def [](definition_node)
+          @dependencies[definition_node]
+        end
+      end
+
+      class NodeWithPath
+        extend Forwardable
+        attr_reader :node, :path
+        def initialize(node, path)
+          @node = node
+          @path = path
+        end
+
+        def_delegators :@node, :name, :eql?, :hash
+      end
+
+      private
+
+      # Return a hash of { node => [node, node ... ]} pairs
+      # Keys are top-level definitions
+      # Values are arrays of flattened dependencies
+      def resolve_dependencies
+        dependency_map = DependencyMap.new
+        # Don't allow the loop to run more times
+        # than the number of fragments in the document
+        max_loops = @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_names = @fragment_definitions.each_key.select { |name| !@immediate_dependencies.key?(name) }
+
+        while fragment_name = independent_fragment_names.pop
+          loops += 1
+          if loops > max_loops
+            raise("Resolution loops exceeded the number of definitions; infinite loop detected.")
+          end
+          fragment_node = @fragment_definitions[fragment_name]
+          # Since it's independent, let's remove it from here.
+          # That way, we can use the remainder to identify cycles
+          @immediate_dependencies.delete(fragment_name)
+          fragment_usages = @dependent_definitions[fragment_name]
+          if fragment_usages.none?
+            # If we didn't record any usages during the visit,
+            # then this fragment is unused.
+            dependency_map.unused_dependencies << fragment_node
+          else
+            fragment_usages.each do |definition_node|
+              # Register the dependency AND second-order dependencies
+              dependency_map[definition_node] << fragment_node
+              dependency_map[definition_node].concat(dependency_map[fragment_node])
+              # Since we've regestered it, remove it from our to-do list
+              deps = @immediate_dependencies[definition_node.name]
+              # Can't find a way to _just_ delete from `deps` and return the deleted entries
+              removed, remaining = deps.partition { |spread| spread.name == fragment_name }
+              @immediate_dependencies[definition_node.name] = remaining
+              if block_given?
+                yield(definition_node, removed, fragment_node)
+              end
+              if remaining.none? && definition_node.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+                # If all of this definition's dependencies have
+                # been resolved, we can now resolve its
+                # own dependents.
+                independent_fragment_names << definition_node.name
+              end
+            end
+          end
+        end
+
+        # If any dependencies were _unmet_
+        # (eg, spreads with no corresponding definition)
+        # then they're still in there
+        @immediate_dependencies.each do |defn_name, deps|
+          deps.each do |spread|
+            if @fragment_definitions[spread.name].nil?
+              defn_node = @fragment_definitions[defn_name]
+              dependency_map.unmet_dependencies[defn_node] << spread
+              deps.delete(spread)
+            end
+          end
+          if deps.none?
+            @immediate_dependencies.delete(defn_name)
+          end
+        end
+
+        # Anything left in @immediate_dependencies is cyclical
+        cyclical_nodes = @immediate_dependencies.keys.map { |n| @fragment_definitions[n] }
+        # @immediate_dependencies also includes operation names, but we don't care about
+        # those. They became nil when we looked them up on `@fragment_definitions`, so remove them.
+        cyclical_nodes.compact!
+        dependency_map.cyclical_definitions.concat(cyclical_nodes)
+
+        dependency_map
+      end
+    end
+  end
+end

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

@@ -3,105 +3,37 @@ module GraphQL
   module StaticValidation
     class FieldsWillMerge
       def validate(context)
-        fragments = {}
-        has_selections = []
-        visitor = context.visitor
-        visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
-          if node.selections.any?
-            has_selections << node
-          end
-        }
-        visitor[GraphQL::Language::Nodes::Document].leave << ->(node, parent) {
-          has_selections.each { |node|
-            field_map = gather_fields_by_name(node.selections, {}, [], context)
-            find_conflicts(field_map, [], context)
-          }
-        }
-      end
-
-      private
-
-      def find_conflicts(field_map, visited_fragments, context)
-        field_map.each do |name, ast_fields|
-          comparison = FieldDefinitionComparison.new(name, ast_fields, context)
-          context.errors.push(*comparison.errors)
-
-
-          subfield_map = {}
-          ast_fields.each do |defn|
-            gather_fields_by_name(defn.selections, subfield_map, visited_fragments, context)
-          end
-
-          find_conflicts(subfield_map, visited_fragments, context)
-        end
-      end
-
-      def gather_fields_by_name(fields, field_map, visited_fragments, context)
-        fields.each do |field|
-          case field
-          when GraphQL::Language::Nodes::InlineFragment
-            next_fields = field.selections
-          when GraphQL::Language::Nodes::FragmentSpread
-            if visited_fragments.include?(field.name)
-              next
-            else
-              visited_fragments << field.name
+        context.each_irep_node do |node|
+          if node.ast_nodes.size > 1
+
+            # Check for more than one GraphQL::Field backing this node:
+            if node.definitions.size > 1
+              defn_names = node.definitions.map { |d| d.name }.sort.join(" or ")
+              msg = "Field '#{node.name}' has a field conflict: #{defn_names}?"
+              context.errors << GraphQL::StaticValidation::Message.new(msg, nodes: node.ast_nodes.to_a)
             end
-            fragment_defn = context.fragments[field.name]
-            next_fields = fragment_defn ? fragment_defn.selections : []
-          when GraphQL::Language::Nodes::Field
-            name_in_selection = field.alias || field.name
-            field_map[name_in_selection] ||= []
-            field_map[name_in_selection].push(field)
-            next_fields = []
-          else
-            raise "Unexpected field for merging: #{field}"
-          end
-          gather_fields_by_name(next_fields, field_map, visited_fragments, context)
-        end
-        field_map
-      end
-
-      # Compare two field definitions, add errors to the list if there are any
-      class FieldDefinitionComparison
-        include GraphQL::StaticValidation::Message::MessageHelper
-        NAMED_VALUES = [GraphQL::Language::Nodes::Enum, GraphQL::Language::Nodes::VariableIdentifier]
-        attr_reader :errors
-        def initialize(name, defs, context)
-          errors = []
-
-          names = defs.map(&:name).uniq
-          if names.length != 1
-            errors << message("Field '#{name}' has a field conflict: #{names.join(" or ")}?", defs.first, context: context)
-          end
 
-          args = defs.map { |defn| reduce_list(defn.arguments)}.uniq
-          if args.length != 1
-            errors << message("Field '#{name}' has an argument conflict: #{args.map{ |arg| GraphQL::Language.serialize(arg) }.join(" or ")}?", defs.first, context: context)
-          end
-
-          @errors = errors
-        end
-
-        private
-
-        def print_arg(arg)
-          case arg
-          when GraphQL::Language::Nodes::VariableIdentifier
-            "$#{arg.name}"
-          when GraphQL::Language::Nodes::Enum
-            "#{arg.name}"
-          else
-            GraphQL::Language.serialize(arg)
-          end
-        end
+            # Check for incompatible / non-identical arguments on this node:
+            args = node.ast_nodes.map do |n|
+              n.arguments.reduce({}) do |memo, a|
+                arg_value = a.value
+                memo[a.name] = case arg_value
+                when GraphQL::Language::Nodes::VariableIdentifier
+                  "$#{arg_value.name}"
+                when GraphQL::Language::Nodes::Enum
+                  "#{arg_value.name}"
+                else
+                  GraphQL::Language.serialize(arg_value)
+                end
+                memo
+              end
+            end
+            args.uniq!
 
-        # Turn AST tree into a hash
-        # can't look up args, the names just have to match
-        def reduce_list(args)
-          args.reduce({}) do |memo, a|
-            memo[a.name] = print_arg(a.value)
-            memo
+            if args.length > 1
+              msg = "Field '#{node.name}' has an argument conflict: #{args.map{ |arg| GraphQL::Language.serialize(arg) }.join(" or ")}?"
+              context.errors << GraphQL::StaticValidation::Message.new(msg, nodes: node.ast_nodes.to_a)
+            end
           end
         end
       end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentNamesAreUnique
+      include GraphQL::StaticValidation::Message::MessageHelper
+
+      def validate(context)
+        fragments_by_name = Hash.new { |h, k| h[k] = [] }
+        context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << ->(node, parent) {
+          fragments_by_name[node.name] << node
+        }
+
+        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(node, parent) {
+          fragments_by_name.each do |name, fragments|
+            if fragments.length > 1
+              context.errors << message(%|Fragment name "#{name}" must be unique|, fragments, context: context)
+            end
+          end
+        }
+      end
+    end
+  end
+end