graphql 0.12.1 → 0.13.0

data/lib/graphql/static_validation/literal_validator.rb

@@ -1,48 +1,52 @@
-# Test whether `ast_value` is a valid input for `type`
-class GraphQL::StaticValidation::LiteralValidator
-  def validate(ast_value, type)
-    if type.kind.non_null?
-      (!ast_value.nil?) && validate(ast_value, type.of_type)
-    elsif type.kind.list?
-      item_type = type.of_type
-      ensure_array(ast_value).all? { |val| validate(val, item_type) }
-    elsif type.kind.scalar? && !ast_value.is_a?(GraphQL::Language::Nodes::AbstractNode) && !ast_value.is_a?(Array)
-      type.valid_input?(ast_value)
-    elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-      type.valid_input?(ast_value.name)
-    elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
-      required_input_fields_are_present(type, ast_value) &&
-        present_input_field_values_are_valid(type, ast_value)
-    elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-      true
-    else
-      false
-    end
-  end
+module GraphQL
+  module StaticValidation
+    # Test whether `ast_value` is a valid input for `type`
+    class LiteralValidator
+      def validate(ast_value, type)
+        if type.kind.non_null?
+          (!ast_value.nil?) && validate(ast_value, type.of_type)
+        elsif type.kind.list?
+          item_type = type.of_type
+          ensure_array(ast_value).all? { |val| validate(val, item_type) }
+        elsif type.kind.scalar? && !ast_value.is_a?(GraphQL::Language::Nodes::AbstractNode) && !ast_value.is_a?(Array)
+          type.valid_input?(ast_value)
+        elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
+          type.valid_input?(ast_value.name)
+        elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
+          required_input_fields_are_present(type, ast_value) &&
+            present_input_field_values_are_valid(type, ast_value)
+        elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          true
+        else
+          false
+        end
+      end
 
 
-  private
+      private
 
 
-  def required_input_fields_are_present(type, ast_node)
-    required_field_names = type.input_fields
-      .values
-      .select { |f| f.type.kind.non_null? }
-      .map(&:name)
-    present_field_names = ast_node.arguments.map(&:name)
-    missing_required_field_names = required_field_names - present_field_names
-    missing_required_field_names.none?
-  end
+      def required_input_fields_are_present(type, ast_node)
+        required_field_names = type.input_fields
+          .values
+          .select { |f| f.type.kind.non_null? }
+          .map(&:name)
+        present_field_names = ast_node.arguments.map(&:name)
+        missing_required_field_names = required_field_names - present_field_names
+        missing_required_field_names.none?
+      end
 
-  def present_input_field_values_are_valid(type, ast_node)
-    fields = type.input_fields
-    ast_node.arguments.all? do |value|
-      field = fields[value.name]
-      field ? validate(value.value, field.type) : true
-    end
-  end
+      def present_input_field_values_are_valid(type, ast_node)
+        fields = type.input_fields
+        ast_node.arguments.all? do |value|
+          field = fields[value.name]
+          field ? validate(value.value, field.type) : true
+        end
+      end
 
-  def ensure_array(value)
-    value.is_a?(Array) ? value : [value]
+      def ensure_array(value)
+        value.is_a?(Array) ? value : [value]
+      end
+    end
   end
 end

data/lib/graphql/static_validation/message.rb

@@ -1,32 +1,36 @@
-# Generates GraphQL-compliant validation message.
-# Only supports one "location", too bad :(
-class GraphQL::StaticValidation::Message
-  # 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)
-    end
-  end
-  attr_reader :message, :line, :col
+module GraphQL
+  module StaticValidation
+    # Generates GraphQL-compliant validation message.
+    # Only supports one "location", too bad :(
+    class Message
+      # 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)
+        end
+      end
+      attr_reader :message, :line, :col
 
-  def initialize(message, line: nil, col: nil)
-    @message = message
-    @line = line
-    @col = col
-  end
+      def initialize(message, line: nil, col: nil)
+        @message = message
+        @line = line
+        @col = col
+      end
 
-  # A hash representation of this Message
-  def to_h
-    {
-      "message" => message,
-      "locations" => locations
-    }
-  end
+      # A hash representation of this Message
+      def to_h
+        {
+          "message" => message,
+          "locations" => locations
+        }
+      end
 
-  private
+      private
 
-  def locations
-    @line.nil? && @col.nil ? [] : [{"line" => @line, "column" => @col}]
+      def locations
+        @line.nil? && @col.nil? ? [] : [{"line" => @line, "column" => @col}]
+      end
+    end
   end
 end

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

@@ -1,14 +1,18 @@
-class GraphQL::StaticValidation::ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
-  def validate_node(parent, node, defn, context)
-    return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-    validator = GraphQL::StaticValidation::LiteralValidator.new
-    arg_defn = defn.arguments[node.name]
-    return unless arg_defn
-    valid = validator.validate(node.value, arg_defn.type)
-    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)
+module GraphQL
+  module StaticValidation
+    class ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
+      def validate_node(parent, node, defn, context)
+        return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+        validator = GraphQL::StaticValidation::LiteralValidator.new
+        arg_defn = defn.arguments[node.name]
+        return unless arg_defn
+        valid = validator.validate(node.value, arg_defn.type)
+        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)
+        end
+      end
     end
   end
 end

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

@@ -1,13 +1,17 @@
-class GraphQL::StaticValidation::ArgumentsAreDefined < GraphQL::StaticValidation::ArgumentsValidator
-  def validate_node(parent, node, defn, context)
-    argument_defn = defn.arguments[node.name]
-    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)
-      GraphQL::Language::Visitor::SKIP
-    else
-      nil
+module GraphQL
+  module StaticValidation
+    class ArgumentsAreDefined < GraphQL::StaticValidation::ArgumentsValidator
+      def validate_node(parent, node, defn, context)
+        argument_defn = defn.arguments[node.name]
+        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)
+          GraphQL::Language::Visitor::SKIP
+        else
+          nil
+        end
+      end
     end
   end
 end

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

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

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

@@ -0,0 +1,59 @@
+module GraphQL
+  module StaticValidation
+    class DirectivesAreInValidLocations
+      include GraphQL::StaticValidation::Message::MessageHelper
+      include GraphQL::Language
+
+      def validate(context)
+        directives = context.schema.directives
+
+        context.visitor[Nodes::Directive] << -> (node, parent) {
+          validate_location(node, parent, directives, context.errors)
+        }
+      end
+
+      private
+
+      LOCATION_MESSAGE_NAMES = {
+        GraphQL::Directive::QUERY =>               "queries",
+        GraphQL::Directive::MUTATION =>            "mutations",
+        GraphQL::Directive::SUBSCRIPTION =>        "subscriptions",
+        GraphQL::Directive::FIELD =>               "fields",
+        GraphQL::Directive::FRAGMENT_DEFINITION => "fragment definitions",
+        GraphQL::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
+        GraphQL::Directive::INLINE_FRAGMENT =>     "inline fragments",
+      }
+
+      SIMPLE_LOCATIONS = {
+        Nodes::Field =>               GraphQL::Directive::FIELD,
+        Nodes::InlineFragment =>      GraphQL::Directive::INLINE_FRAGMENT,
+        Nodes::FragmentSpread =>      GraphQL::Directive::FRAGMENT_SPREAD,
+        Nodes::FragmentDefinition =>  GraphQL::Directive::FRAGMENT_DEFINITION,
+      }
+
+      SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
+
+      def validate_location(ast_directive, ast_parent, directives, errors)
+        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)
+        when *SIMPLE_LOCATION_NODES
+          required_location = SIMPLE_LOCATIONS[ast_parent.class]
+          assert_includes_location(directive_defn, ast_directive, required_location, errors)
+        else
+          errors << message("Directives can't be applied to #{ast_parent.class.name}s", ast_directive)
+        end
+      end
+
+      def assert_includes_location(directive_defn, directive_ast, required_location, errors)
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -1,28 +1,32 @@
-class GraphQL::StaticValidation::FieldsAreDefinedOnType
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    class FieldsAreDefinedOnType
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  def validate(context)
-    visitor = context.visitor
-    visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
-      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)
-    }
-  end
+      def validate(context)
+        visitor = context.visitor
+        visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
+          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)
+        }
+      end
 
-  private
+      private
 
-  def validate_field(errors, 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)
-      return GraphQL::Language::Visitor::SKIP
-    end
+      def validate_field(errors, 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)
+          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)
-      return GraphQL::Language::Visitor::SKIP
+        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)
+          return GraphQL::Language::Visitor::SKIP
+        end
+      end
     end
   end
 end

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

@@ -1,32 +1,36 @@
-# Scalars _can't_ have selections
-# Objects _must_ have selections
-class GraphQL::StaticValidation::FieldsHaveAppropriateSelections
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    # Scalars _can't_ have selections
+    # Objects _must_ have selections
+    class FieldsHaveAppropriateSelections
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  def validate(context)
-    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)
-    }
-  end
+      def validate(context)
+        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)
+        }
+      end
 
-  private
+      private
 
-  def validate_field_selections(ast_field, field_defn, errors)
-    resolved_type = field_defn.type.unwrap
+      def validate_field_selections(ast_field, field_defn, errors)
+        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)
-    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)
-    else
-      error = nil
-    end
+        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)
+        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)
+        else
+          error = nil
+        end
 
-    if !error.nil?
-      errors << error
-      GraphQL::Language::Visitor::SKIP
+        if !error.nil?
+          errors << error
+          GraphQL::Language::Visitor::SKIP
+        end
+      end
     end
   end
 end

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

@@ -1,100 +1,104 @@
-class GraphQL::StaticValidation::FieldsWillMerge
-  def validate(context)
-    fragments = {}
-    has_selections = []
-    visitor = context.visitor
-    visitor[GraphQL::Language::Nodes::OperationDefinition] << -> (node, parent) {
-      if node.selections.any?
-        has_selections << node
+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
-    }
-    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
+      private
 
-  def find_conflicts(field_map, context)
-    field_map.each do |name, ast_fields|
-      comparison = FieldDefinitionComparison.new(name, ast_fields)
-      context.errors.push(*comparison.errors)
+      def find_conflicts(field_map, context)
+        field_map.each do |name, ast_fields|
+          comparison = FieldDefinitionComparison.new(name, ast_fields)
+          context.errors.push(*comparison.errors)
 
 
-      subfield_map = {}
-      visited_fragments = []
-      ast_fields.each do |defn|
-        gather_fields_by_name(defn.selections, subfield_map, visited_fragments, context)
+          subfield_map = {}
+          visited_fragments = []
+          ast_fields.each do |defn|
+            gather_fields_by_name(defn.selections, subfield_map, visited_fragments, context)
+          end
+          find_conflicts(subfield_map, context)
+        end
       end
-      find_conflicts(subfield_map, context)
-    end
-  end
 
-  def gather_fields_by_name(fields, field_map, visited_fragments, context)
-    fields.each do |field|
-      if field.is_a?(GraphQL::Language::Nodes::InlineFragment)
-        next_fields = field.selections
-      elsif field.is_a?(GraphQL::Language::Nodes::FragmentSpread)
-        if visited_fragments.include?(field.name)
-          next
-        else
-          visited_fragments << field.name
+      def gather_fields_by_name(fields, field_map, visited_fragments, context)
+        fields.each do |field|
+          if field.is_a?(GraphQL::Language::Nodes::InlineFragment)
+            next_fields = field.selections
+          elsif field.is_a?(GraphQL::Language::Nodes::FragmentSpread)
+            if visited_fragments.include?(field.name)
+              next
+            else
+              visited_fragments << field.name
+            end
+            fragment_defn = context.fragments[field.name]
+            next_fields = fragment_defn ? fragment_defn.selections : []
+          else
+            name_in_selection = field.alias || field.name
+            field_map[name_in_selection] ||= []
+            field_map[name_in_selection].push(field)
+            next_fields = []
+          end
+          gather_fields_by_name(next_fields, field_map, visited_fragments, context)
         end
-        fragment = context.fragments[field.name]
-        next_fields = fragment.selections
-      else
-        name_in_selection = field.alias || field.name
-        field_map[name_in_selection] ||= []
-        field_map[name_in_selection].push(field)
-        next_fields = []
+        field_map
       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)
-      errors = []
+      # 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)
+          errors = []
 
-      names = defs.map(&:name).uniq
-      if names.length != 1
-        errors << message("Field '#{name}' has a field conflict: #{names.join(" or ")}?", defs.first)
-      end
+          names = defs.map(&:name).uniq
+          if names.length != 1
+            errors << message("Field '#{name}' has a field conflict: #{names.join(" or ")}?", defs.first)
+          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)
-      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)
+          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)
-      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)
+          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)
-      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)
+          end
 
-      @errors = errors
-    end
+          @errors = errors
+        end
 
-    private
+        private
 
-    # 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] = NAMED_VALUES.include?(a.value.class) ? a.value.name : a.value
-        memo
+        # 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] = NAMED_VALUES.include?(a.value.class) ? a.value.name : a.value
+            memo
+          end
+        end
       end
     end
   end