graphql 0.17.2 → 0.18.0

data/lib/graphql/schema.rb

@@ -26,6 +26,9 @@ module GraphQL
       :mutation_execution_strategy,
       :subscription_execution_strategy
 
+    # @return [GraphQL::Relay::GlobalNodeIdentification] the node identification instance for this schema, when using Relay
+    attr_accessor :node_identification
+
     # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
     attr_reader :middleware
 

data/lib/graphql/schema/printer.rb

@@ -28,7 +28,17 @@ module GraphQL
 
       def print_filtered_schema(schema, type_filter)
         types = schema.types.values.select{ |type| type_filter.call(type) }.sort_by(&:name)
-        types.map{ |type| print_type(type) }.join("\n\n")
+        type_definitions = types.map{ |type| print_type(type) }
+
+        [print_schema_definition(schema)].concat(type_definitions).join("\n\n")
+      end
+
+      def print_schema_definition(schema)
+        operations = [:query, :mutation, :subscription].map do |operation_type|
+          object_type = schema.public_send(operation_type)
+          "  #{operation_type}: #{object_type.name}\n" if object_type
+        end.compact.join
+        "schema {\n#{operations}}"
       end
 
       BUILTIN_SCALARS = Set.new(["String", "Boolean", "Int", "Float", "ID"])
@@ -122,7 +132,7 @@ module GraphQL
 
         class UnionPrinter
           def self.print(type)
-            "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}\n}"
+            "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}"
           end
         end
 

data/lib/graphql/static_validation/message.rb

@@ -6,23 +6,27 @@ module GraphQL
       # Convenience for validators
       module MessageHelper
         # Error `message` is located at `node`
-        def message(message, node)
-          GraphQL::StaticValidation::Message.new(message, line: node.line, col: node.col)
+        def message(message, node, context: nil, path: nil)
+          path ||= context.path
+          GraphQL::StaticValidation::Message.new(message, line: node.line, col: node.col, path: path)
         end
       end
-      attr_reader :message, :line, :col
 
-      def initialize(message, line: nil, col: nil)
+      attr_reader :message, :line, :col, :path
+
+      def initialize(message, line: nil, col: nil, path: [])
         @message = message
         @line = line
         @col = col
+        @path = path
       end
 
       # A hash representation of this Message
       def to_h
         {
           "message" => message,
-          "locations" => locations
+          "locations" => locations,
+          "path" => path,
         }
       end
 

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

@@ -10,7 +10,7 @@ module GraphQL
         if !valid
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
-          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value", parent)
+          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value", parent, context: context)
         end
       end
     end

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

@@ -6,7 +6,7 @@ module GraphQL
         if argument_defn.nil?
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
-          context.errors << message("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", parent)
+          context.errors << message("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", parent, context: context)
           GraphQL::Language::Visitor::SKIP
         else
           nil

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

@@ -6,15 +6,15 @@ module GraphQL
       def validate(context)
         directive_names = context.schema.directives.keys
         context.visitor[GraphQL::Language::Nodes::Directive] << -> (node, parent) {
-          validate_directive(node, directive_names, context.errors)
+          validate_directive(node, directive_names, context)
         }
       end
 
       private
 
-      def validate_directive(ast_directive, directive_names, errors)
+      def validate_directive(ast_directive, directive_names, context)
         if !directive_names.include?(ast_directive.name)
-          errors << message("Directive @#{ast_directive.name} is not defined", ast_directive)
+          context.errors << message("Directive @#{ast_directive.name} is not defined", ast_directive, context: context)
         end
       end
     end

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

@@ -8,7 +8,7 @@ module GraphQL
         directives = context.schema.directives
 
         context.visitor[Nodes::Directive] << -> (node, parent) {
-          validate_location(node, parent, directives, context.errors)
+          validate_location(node, parent, directives, context)
         }
       end
 
@@ -33,25 +33,25 @@ module GraphQL
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
 
-      def validate_location(ast_directive, ast_parent, directives, errors)
+      def validate_location(ast_directive, ast_parent, directives, context)
         directive_defn = directives[ast_directive.name]
         case ast_parent
         when Nodes::OperationDefinition
           required_location = GraphQL::Directive.const_get(ast_parent.operation_type.upcase)
-          assert_includes_location(directive_defn, ast_directive, required_location, errors)
+          assert_includes_location(directive_defn, ast_directive, required_location, context)
         when *SIMPLE_LOCATION_NODES
           required_location = SIMPLE_LOCATIONS[ast_parent.class]
-          assert_includes_location(directive_defn, ast_directive, required_location, errors)
+          assert_includes_location(directive_defn, ast_directive, required_location, context)
         else
-          errors << message("Directives can't be applied to #{ast_parent.class.name}s", ast_directive)
+          context.errors << message("Directives can't be applied to #{ast_parent.class.name}s", ast_directive, context: context)
         end
       end
 
-      def assert_includes_location(directive_defn, directive_ast, required_location, errors)
+      def assert_includes_location(directive_defn, directive_ast, required_location, context)
         if !directive_defn.locations.include?(required_location)
           location_name = LOCATION_MESSAGE_NAMES[required_location]
           allowed_location_names = directive_defn.locations.map { |loc| LOCATION_MESSAGE_NAMES[loc] }
-          errors << message("'@#{directive_defn.name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})", directive_ast)
+          context.errors << message("'@#{directive_defn.name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})", directive_ast, context: context)
         end
       end
     end

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

@@ -9,21 +9,21 @@ module GraphQL
           return if context.skip_field?(node.name)
           parent_type = context.object_types[-2]
           parent_type = parent_type.unwrap
-          validate_field(context.errors, node, parent_type, parent)
+          validate_field(context, node, parent_type, parent)
         }
       end
 
       private
 
-      def validate_field(errors, ast_field, parent_type, parent)
+      def validate_field(context, ast_field, parent_type, parent)
         if parent_type.kind.union?
-          errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent)
+          context.errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent, context: context)
           return GraphQL::Language::Visitor::SKIP
         end
 
         field =  parent_type.get_field(ast_field.name)
         if field.nil?
-          errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent)
+          context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent, context: context)
           return GraphQL::Language::Visitor::SKIP
         end
       end

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

@@ -9,25 +9,25 @@ module GraphQL
         context.visitor[GraphQL::Language::Nodes::Field] << -> (node, parent)  {
           return if context.skip_field?(node.name)
           field_defn = context.field_definition
-          validate_field_selections(node, field_defn, context.errors)
+          validate_field_selections(node, field_defn, context)
         }
       end
 
       private
 
-      def validate_field_selections(ast_field, field_defn, errors)
+      def validate_field_selections(ast_field, field_defn, context)
         resolved_type = field_defn.type.unwrap
 
         if resolved_type.kind.scalar? && ast_field.selections.any?
-          error = message("Selections can't be made on scalars (field '#{ast_field.name}' returns #{resolved_type.name} but has selections [#{ast_field.selections.map(&:name).join(", ")}])", ast_field)
+          error = message("Selections can't be made on scalars (field '#{ast_field.name}' returns #{resolved_type.name} but has selections [#{ast_field.selections.map(&:name).join(", ")}])", ast_field, context: context)
         elsif resolved_type.kind.object? && ast_field.selections.none?
-          error = message("Objects must have selections (field '#{ast_field.name}' returns #{resolved_type.name} but has no selections)", ast_field)
+          error = message("Objects must have selections (field '#{ast_field.name}' returns #{resolved_type.name} but has no selections)", ast_field, context: context)
         else
           error = nil
         end
 
         if !error.nil?
-          errors << error
+          context.errors << error
           GraphQL::Language::Visitor::SKIP
         end
       end

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

@@ -22,7 +22,7 @@ module GraphQL
 
       def find_conflicts(field_map, context)
         field_map.each do |name, ast_fields|
-          comparison = FieldDefinitionComparison.new(name, ast_fields)
+          comparison = FieldDefinitionComparison.new(name, ast_fields, context)
           context.errors.push(*comparison.errors)
 
 
@@ -63,27 +63,27 @@ module GraphQL
         include GraphQL::StaticValidation::Message::MessageHelper
         NAMED_VALUES = [GraphQL::Language::Nodes::Enum, GraphQL::Language::Nodes::VariableIdentifier]
         attr_reader :errors
-        def initialize(name, defs)
+        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)
+            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 {|a| JSON.dump(a) }.join(" or ")}?", defs.first)
+            errors << message("Field '#{name}' has an argument conflict: #{args.map {|a| JSON.dump(a) }.join(" or ")}?", defs.first, context: context)
           end
 
           directive_names = defs.map { |defn| defn.directives.map(&:name) }.uniq
           if directive_names.length != 1
-            errors << message("Field '#{name}' has a directive conflict: #{directive_names.map {|names| "[#{names.join(", ")}]"}.join(" or ")}?", defs.first)
+            errors << message("Field '#{name}' has a directive conflict: #{directive_names.map {|names| "[#{names.join(", ")}]"}.join(" or ")}?", defs.first, context: context)
           end
 
           directive_args = defs.map {|defn| defn.directives.map {|d| reduce_list(d.arguments) } }.uniq
           if directive_args.length != 1
-            errors << message("Field '#{name}' has a directive argument conflict: #{directive_args.map {|args| JSON.dump(args)}.join(" or ")}?", defs.first)
+            errors << message("Field '#{name}' has a directive argument conflict: #{directive_args.map {|args| JSON.dump(args)}.join(" or ")}?", defs.first, context: context)
           end
 
           @errors = errors

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

@@ -9,7 +9,7 @@ module GraphQL
           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)
+            validate_fragment_in_scope(fragment_parent, fragment_child, node, context, context.path)
           end
         }
 
@@ -17,26 +17,25 @@ module GraphQL
 
         context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
           fragment_parent = context.object_types.last
-          spreads_to_validate << [node, fragment_parent]
+          spreads_to_validate << FragmentSpread.new(node: node, parent_type: fragment_parent, path: context.path)
         }
 
-        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
+        context.visitor[GraphQL::Language::Nodes::Document].leave << -> (doc_node, parent) {
+          spreads_to_validate.each do |frag_spread|
+            fragment_child_name = context.fragments[frag_spread.node.name].type
             fragment_child = context.schema.types[fragment_child_name]
-            validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
+            validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
           end
         }
       end
 
       private
 
-      def validate_fragment_in_scope(parent_type, child_type, node, context)
+      def validate_fragment_in_scope(parent_type, child_type, node, context, path)
         intersecting_types = get_possible_types(parent_type, context.schema) & get_possible_types(child_type, context.schema)
         if intersecting_types.none?
           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)
+          context.errors << message("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node, path: path)
         end
       end
 
@@ -51,6 +50,15 @@ module GraphQL
           []
         end
       end
+
+      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
   end
 end

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

@@ -20,7 +20,7 @@ module GraphQL
         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)
+          context.errors << message("No such type #{node.type}, so it can't be a fragment condition", node, context: context)
           GraphQL::Language::Visitor::SKIP
         end
       end

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

@@ -6,7 +6,7 @@ module GraphQL
       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)
+            context.errors << message("Fragment #{node.name} contains an infinite loop", node, context: context)
           end
         }
       end

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

@@ -23,7 +23,7 @@ module GraphQL
         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)
+          context.errors <<  message("Invalid fragment on type #{type_name} (must be Union, Interface or Object)", node, context: context)
           GraphQL::Language::Visitor::SKIP
         end
       end

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

@@ -9,35 +9,46 @@ module GraphQL
         defined_fragments = []
 
         v[GraphQL::Language::Nodes::Document] << -> (node, parent) {
-          defined_fragments = node.definitions.select { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+          defined_fragments = node.definitions
+            .select { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+            .map { |node| FragmentInstance.new(node: node, path: context.path) }
         }
 
         v[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
-          used_fragments << node
+          used_fragments << FragmentInstance.new(node: node, path: context.path)
           if defined_fragments.none? { |defn| defn.name == node.name }
             GraphQL::Language::Visitor::SKIP
           end
         }
-        v[GraphQL::Language::Nodes::Document].leave << -> (node, parent) { add_errors(context.errors, used_fragments, defined_fragments) }
+        v[GraphQL::Language::Nodes::Document].leave << -> (node, parent) { add_errors(context, used_fragments, defined_fragments) }
       end
 
       private
 
-      def add_errors(errors, used_fragments, defined_fragments)
+      def add_errors(context, 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)
+          context.errors << message("Fragment #{fragment.name} was used, but not defined", fragment.node, path: fragment.path)
         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)
+          context.errors << message("Fragment #{fragment.name} was defined, but not used", fragment.node, path: fragment.path)
         end
       end
 
       def find_difference(fragments, allowed_fragment_names)
         fragments.select {|f| !allowed_fragment_names.include?(f.name) }
       end
+
+      class FragmentInstance
+        attr_reader :name, :node, :path
+        def initialize(node:, path:)
+          @node = node
+          @name = node.name
+          @path = path
+        end
+      end
     end
   end
 end

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

@@ -30,7 +30,7 @@ module GraphQL
 
         missing_names = required_argument_names - present_argument_names
         if missing_names.any?
-          context.errors << message("#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}", ast_node)
+          context.errors << message("#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}", ast_node, context: context)
         end
       end
     end

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

@@ -15,11 +15,11 @@ module GraphQL
       def validate_default_value(node, literal_validator, context)
         value = node.default_value
         if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
-          context.errors << message("Non-null variable $#{node.name} can't have a default value", node)
+          context.errors << message("Non-null variable $#{node.name} can't have a default value", node, context: context)
         else
           type = context.schema.type_from_ast(node.type)
           if !literal_validator.validate(value, type)
-            context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node)
+            context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node, context: context)
           end
         end
       end

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

@@ -44,11 +44,11 @@ module GraphQL
         arg_inner_type = arg_defn_type.unwrap
 
         if var_inner_type != arg_inner_type
-          context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node)
+          context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node, context)
         elsif list_dimension(var_type) != list_dimension(arg_defn_type)
-          context.errors << create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node)
+          context.errors << create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node, context)
         elsif !non_null_levels_match(arg_defn_type, var_type)
-          context.errors << create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
+          context.errors << create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node, context)
         end
       end
 
@@ -62,8 +62,8 @@ module GraphQL
         end
       end
 
-      def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
-        message("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node)
+      def create_error(error_message, var_type, ast_var, arg_defn, arg_node, context)
+        message("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node, context: context)
       end
 
       def list_dimension(type)

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

@@ -15,7 +15,7 @@ module GraphQL
         type_name = get_type_name(node.type)
         type = context.schema.types[type_name]
         if !type.kind.input?
-          context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node)
+          context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node, context: context)
         end
       end