graphql 0.16.0 → 2.0.15

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

@@ -1,54 +1,71 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentSpreadsArePossible
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-
-        context.visitor[GraphQL::Language::Nodes::InlineFragment] << -> (node, parent) {
-          fragment_parent = context.object_types[-2]
-          fragment_child = context.object_types.last
-          if fragment_child
-            validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
-          end
-        }
+    module FragmentSpreadsArePossible
+      def initialize(*)
+        super
+        @spreads_to_validate = []
+      end
 
-        spreads_to_validate = []
+      def on_inline_fragment(node, parent)
+        fragment_parent = context.object_types[-2]
+        fragment_child = context.object_types.last
+        if fragment_child
+          validate_fragment_in_scope(fragment_parent, fragment_child, node, context, context.path)
+        end
+        super
+      end
 
-        context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
-          fragment_parent = context.object_types.last
-          spreads_to_validate << [node, fragment_parent]
-        }
+      def on_fragment_spread(node, parent)
+        fragment_parent = context.object_types.last
+        @spreads_to_validate << FragmentSpread.new(node: node, parent_type: fragment_parent, path: context.path)
+        super
+      end
 
-        context.visitor[GraphQL::Language::Nodes::Document].leave << -> (node, parent) {
-          spreads_to_validate.each do |spread_values|
-            node, fragment_parent = spread_values
-            fragment_child_name = context.fragments[node.name].type
-            fragment_child = context.schema.types[fragment_child_name]
-            validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
+      def on_document(node, parent)
+        super
+        @spreads_to_validate.each do |frag_spread|
+          frag_node = context.fragments[frag_spread.node.name]
+          if frag_node
+            fragment_child_name = frag_node.type.name
+            fragment_child = context.warden.get_type(fragment_child_name)
+            # Might be non-existent type name
+            if fragment_child
+              validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
+            end
           end
-        }
+        end
       end
 
       private
 
-      def validate_fragment_in_scope(parent_type, child_type, node, context)
-        intersecting_types = get_possible_types(parent_type, context.schema) & get_possible_types(child_type, context.schema)
-        if intersecting_types.none?
+      def validate_fragment_in_scope(parent_type, child_type, node, context, path)
+        if !child_type.kind.fields?
+          # It's not a valid fragment type, this error was handled someplace else
+          return
+        end
+        parent_types = context.warden.possible_types(parent_type.unwrap)
+        child_types = context.warden.possible_types(child_type.unwrap)
+
+        if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""
-          context.errors << message("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node)
+          add_error(GraphQL::StaticValidation::FragmentSpreadsArePossibleError.new(
+            "Fragment#{name} on #{child_type.graphql_name} can't be spread inside #{parent_type.graphql_name}",
+            nodes: node,
+            path: path,
+            fragment_name: name.empty? ? "unknown" : name,
+            type: child_type.graphql_name,
+            parent: parent_type.graphql_name
+          ))
         end
       end
 
-      def get_possible_types(type, schema)
-        if type.kind.wraps?
-          get_possible_types(type.of_type, schema)
-        elsif type.kind.object?
-          [type]
-        elsif type.kind.resolves?
-          schema.possible_types(type)
-        else
-          []
+      class FragmentSpread
+        attr_reader :node, :parent_type, :path
+        def initialize(node:, parent_type:, path:)
+          @node = node
+          @parent_type = parent_type
+          @path = path
         end
       end
     end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentSpreadsArePossibleError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :fragment_name
+      attr_reader :parent_name
+
+      def initialize(message, path: nil, nodes: [], type:, fragment_name:, parent:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @fragment_name = fragment_name
+        @parent_name = parent
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name,
+          "fragmentName" => fragment_name,
+          "parentName" => parent_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "cannotSpreadFragment"
+      end
+    end
+  end
+end

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

@@ -1,27 +1,37 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentTypesExist
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      FRAGMENTS_ON_TYPES = [
-        GraphQL::Language::Nodes::FragmentDefinition,
-        GraphQL::Language::Nodes::InlineFragment,
-      ]
+    module FragmentTypesExist
+      def on_fragment_definition(node, _parent)
+        if validate_type_exists(node)
+          super
+        end
+      end
 
-      def validate(context)
-        FRAGMENTS_ON_TYPES.each do |node_class|
-          context.visitor[node_class] << -> (node, parent) { validate_type_exists(node, context) }
+      def on_inline_fragment(node, _parent)
+        if validate_type_exists(node)
+          super
         end
       end
 
       private
 
-      def validate_type_exists(node, context)
-        return unless node.type
-        type = context.schema.types.fetch(node.type, nil)
-        if type.nil?
-          context.errors << message("No such type #{node.type}, so it can't be a fragment condition", node)
-          GraphQL::Language::Visitor::SKIP
+      def validate_type_exists(fragment_node)
+        if !fragment_node.type
+          true
+        else
+          type_name = fragment_node.type.name
+          type = context.warden.get_type(type_name)
+          if type.nil?
+            add_error(GraphQL::StaticValidation::FragmentTypesExistError.new(
+              "No such type #{type_name}, so it can't be a fragment condition",
+              nodes: fragment_node,
+              type: type_name
+            ))
+            false
+          else
+            true
+          end
         end
       end
     end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentTypesExistError < StaticValidation::Error
+      attr_reader :type_name
+
+      def initialize(message, path: nil, nodes: [], type:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "undefinedType"
+      end
+    end
+  end
+end

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

@@ -1,25 +1,19 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentsAreFinite
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << -> (node, parent) {
-          if has_nested_spread(node, [], context)
-            context.errors << message("Fragment #{node.name} contains an infinite loop", node)
+    module FragmentsAreFinite
+      def on_document(_n, _p)
+        super
+        dependency_map = context.dependencies
+        dependency_map.cyclical_definitions.each do |defn|
+          if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+            add_error(GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+              "Fragment #{defn.name} contains an infinite loop",
+              nodes: defn.node,
+              path: defn.path,
+              name: defn.name
+            ))
           end
-        }
-      end
-
-      private
-
-      def has_nested_spread(fragment_def, parent_fragment_names, context)
-        nested_spreads = fragment_def.selections
-          .select {|f| f.is_a?(GraphQL::Language::Nodes::FragmentSpread)}
-
-        nested_spreads.any? do |spread|
-          nested_def = context.fragments[spread.name]
-          parent_fragment_names.include?(spread.name) || has_nested_spread(nested_def, parent_fragment_names + [fragment_def.name], context)
         end
       end
     end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentsAreFiniteError < StaticValidation::Error
+      attr_reader :fragment_name
+
+      def initialize(message, path: nil, nodes: [], name:)
+        super(message, path: path, nodes: nodes)
+        @fragment_name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "fragmentName" => fragment_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "infiniteLoop"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module FragmentsAreNamed
+      def on_fragment_definition(node, _parent)
+        if node.name.nil?
+          add_error(GraphQL::StaticValidation::FragmentsAreNamedError.new(
+            "Fragment definition has no name",
+            nodes: node
+          ))
+        end
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentsAreNamedError < StaticValidation::Error
+
+      def initialize(message, path: nil, nodes: [])
+        super(message, path: path, nodes: nodes)
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "anonymousFragment"
+      end
+    end
+  end
+end

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

@@ -1,30 +1,35 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentsAreOnCompositeTypes
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      HAS_TYPE_CONDITION = [
-        GraphQL::Language::Nodes::FragmentDefinition,
-        GraphQL::Language::Nodes::InlineFragment,
-      ]
+    module FragmentsAreOnCompositeTypes
+      def on_fragment_definition(node, parent)
+        validate_type_is_composite(node) && super
+      end
 
-      def validate(context)
-        HAS_TYPE_CONDITION.each do |node_class|
-          context.visitor[node_class] << -> (node, parent) {
-            validate_type_is_composite(node, context)
-          }
-        end
+      def on_inline_fragment(node, parent)
+        validate_type_is_composite(node) && super
       end
 
       private
 
-      def validate_type_is_composite(node, context)
-        type_name = node.type
-        return unless type_name
-        type_def = context.schema.types[type_name]
-        if type_def.nil? || !type_def.kind.composite?
-          context.errors <<  message("Invalid fragment on type #{type_name} (must be Union, Interface or Object)", node)
-          GraphQL::Language::Visitor::SKIP
+      def validate_type_is_composite(node)
+        node_type = node.type
+        if node_type.nil?
+          # Inline fragment on the same type
+          true
+        else
+          type_name = node_type.to_query_string
+          type_def = context.warden.get_type(type_name)
+          if type_def.nil? || !type_def.kind.composite?
+            add_error(GraphQL::StaticValidation::FragmentsAreOnCompositeTypesError.new(
+              "Invalid fragment on type #{type_name} (must be Union, Interface or Object)",
+              nodes: node,
+              type: type_name
+            ))
+            false
+          else
+            true
+          end
         end
       end
     end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentsAreOnCompositeTypesError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :argument_name
+
+      def initialize(message, path: nil, nodes: [], type:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "fragmentOnNonCompositeType"
+      end
+    end
+  end
+end

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

@@ -1,43 +1,32 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentsAreUsed
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        v = context.visitor
-        used_fragments = []
-        defined_fragments = []
-
-        v[GraphQL::Language::Nodes::Document] << -> (node, parent) {
-          defined_fragments = node.definitions.select { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
-        }
-
-        v[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
-          used_fragments << node
-          if defined_fragments.none? { |defn| defn.name == node.name }
-            GraphQL::Language::Visitor::SKIP
+    module FragmentsAreUsed
+      def on_document(node, parent)
+        super
+        dependency_map = context.dependencies
+        dependency_map.unmet_dependencies.each do |op_defn, spreads|
+          spreads.each do |fragment_spread|
+            add_error(GraphQL::StaticValidation::FragmentsAreUsedError.new(
+              "Fragment #{fragment_spread.name} was used, but not defined",
+              nodes: fragment_spread.node,
+              path: fragment_spread.path,
+              fragment: fragment_spread.name
+            ))
           end
-        }
-        v[GraphQL::Language::Nodes::Document].leave << -> (node, parent) { add_errors(context.errors, used_fragments, defined_fragments) }
-      end
-
-      private
-
-      def add_errors(errors, used_fragments, defined_fragments)
-        undefined_fragments = find_difference(used_fragments, defined_fragments.map(&:name))
-        undefined_fragments.each do |fragment|
-          errors << message("Fragment #{fragment.name} was used, but not defined", fragment)
         end
 
-        unused_fragments = find_difference(defined_fragments, used_fragments.map(&:name))
-        unused_fragments.each do |fragment|
-          errors << message("Fragment #{fragment.name} was defined, but not used", fragment)
+        dependency_map.unused_dependencies.each do |fragment|
+          if fragment && !fragment.name.nil?
+            add_error(GraphQL::StaticValidation::FragmentsAreUsedError.new(
+              "Fragment #{fragment.name} was defined, but not used",
+              nodes: fragment.node,
+              path: fragment.path,
+              fragment: fragment.name
+            ))
+          end
         end
       end
-
-      def find_difference(fragments, allowed_fragment_names)
-        fragments.select {|f| !allowed_fragment_names.include?(f.name) }
-      end
     end
   end
 end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentsAreUsedError < StaticValidation::Error
+      attr_reader :fragment_name
+
+      def initialize(message, path: nil, nodes: [], fragment:)
+        super(message, path: path, nodes: nodes)
+        @fragment_name = fragment
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "fragmentName" => fragment_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "useAndDefineFragment"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module InputObjectNamesAreUnique
+      def on_input_object(node, parent)
+        validate_input_fields(node)
+        super
+      end
+
+      private
+
+      def validate_input_fields(node)
+        input_field_defns = node.arguments
+        input_fields_by_name = Hash.new { |h, k| h[k] = [] }
+        input_field_defns.each { |a| input_fields_by_name[a.name] << a }
+
+        input_fields_by_name.each do |name, defns|
+          if defns.size > 1
+            error = GraphQL::StaticValidation::InputObjectNamesAreUniqueError.new(
+              "There can be only one input field named \"#{name}\"",
+              nodes: defns,
+              name: name
+            )
+            add_error(error)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class InputObjectNamesAreUniqueError < StaticValidation::Error
+      attr_reader :name
+
+      def initialize(message, path: nil, nodes: [], name:)
+        super(message, path: path, nodes: nodes)
+        @name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "name" => name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "inputFieldNotUnique"
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module MutationRootExists
+      def on_operation_definition(node, _parent)
+        if node.operation_type == 'mutation' && context.warden.root_type_for_operation("mutation").nil?
+          add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
+            'Schema is not configured for mutations',
+            nodes: node
+          ))
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class MutationRootExistsError < StaticValidation::Error
+
+      def initialize(message, path: nil, nodes: [])
+        super(message, path: path, nodes: nodes)
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "missingMutationConfiguration"
+      end
+    end
+  end
+end