graphql 0.12.1 → 0.13.0

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

@@ -1,50 +1,56 @@
-class GraphQL::StaticValidation::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
-      validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
-    }
-
-    spreads_to_validate = []
-
-    context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
-      fragment_parent = context.object_types.last
-      spreads_to_validate << [node, fragment_parent]
-    }
-
-    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)
+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
+        }
+
+        spreads_to_validate = []
+
+        context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
+          fragment_parent = context.object_types.last
+          spreads_to_validate << [node, fragment_parent]
+        }
+
+        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)
+          end
+        }
       end
-    }
-  end
 
-  private
+      private
 
-  def validate_fragment_in_scope(parent_type, child_type, node, context)
-    intersecting_types = get_possible_types(parent_type) & get_possible_types(child_type)
-    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)
-    end
-  end
+      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?
+          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)
+        end
+      end
 
-  def get_possible_types(type)
-    if type.kind.wraps?
-      get_possible_types(type.of_type)
-    elsif type.kind.object?
-      [type]
-    elsif type.kind.resolves?
-      type.possible_types
-    else
-      []
+      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
+          []
+        end
+      end
     end
   end
 end

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

@@ -1,24 +1,29 @@
-class GraphQL::StaticValidation::FragmentTypesExist
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    class FragmentTypesExist
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  FRAGMENTS_ON_TYPES = [
-    GraphQL::Language::Nodes::FragmentDefinition,
-    GraphQL::Language::Nodes::InlineFragment,
-  ]
+      FRAGMENTS_ON_TYPES = [
+        GraphQL::Language::Nodes::FragmentDefinition,
+        GraphQL::Language::Nodes::InlineFragment,
+      ]
 
-  def validate(context)
-    FRAGMENTS_ON_TYPES.each do |node_class|
-      context.visitor[node_class] << -> (node, parent) { validate_type_exists(node, context) }
-    end
-  end
+      def validate(context)
+        FRAGMENTS_ON_TYPES.each do |node_class|
+          context.visitor[node_class] << -> (node, parent) { validate_type_exists(node, context) }
+        end
+      end
 
-  private
+      private
 
-  def validate_type_exists(node, context)
-    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(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
+        end
+      end
     end
   end
 end

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

@@ -1,23 +1,27 @@
-class GraphQL::StaticValidation::FragmentsAreFinite
-  include GraphQL::StaticValidation::Message::MessageHelper
+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)
+      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)
+          end
+        }
       end
-    }
-  end
 
-  private
+      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)}
+      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)
+        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
   end
 end

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

@@ -1,27 +1,32 @@
-class GraphQL::StaticValidation::FragmentsAreOnCompositeTypes
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    class FragmentsAreOnCompositeTypes
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  HAS_TYPE_CONDITION = [
-    GraphQL::Language::Nodes::FragmentDefinition,
-    GraphQL::Language::Nodes::InlineFragment,
-  ]
+      HAS_TYPE_CONDITION = [
+        GraphQL::Language::Nodes::FragmentDefinition,
+        GraphQL::Language::Nodes::InlineFragment,
+      ]
 
-  def validate(context)
-    HAS_TYPE_CONDITION.each do |node_class|
-      context.visitor[node_class] << -> (node, parent) {
-        validate_type_is_composite(node, context)
-      }
-    end
-  end
+      def validate(context)
+        HAS_TYPE_CONDITION.each do |node_class|
+          context.visitor[node_class] << -> (node, parent) {
+            validate_type_is_composite(node, context)
+          }
+        end
+      end
 
-  private
+      private
 
-  def validate_type_is_composite(node, context)
-    type_name = node.type
-    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, 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
+        end
+      end
     end
   end
 end

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

@@ -1,30 +1,43 @@
-class GraphQL::StaticValidation::FragmentsAreUsed
-  include GraphQL::StaticValidation::Message::MessageHelper
+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::FragmentSpread] << -> (node, parent) { used_fragments <<  node }
-    v[GraphQL::Language::Nodes::FragmentDefinition] << -> (node, parent) { defined_fragments << node}
-    v[GraphQL::Language::Nodes::Document].leave << -> (node, parent) { add_errors(context.errors, used_fragments, defined_fragments) }
-  end
+      def validate(context)
+        v = context.visitor
+        used_fragments = []
+        defined_fragments = []
 
-  private
+        v[GraphQL::Language::Nodes::Document] << -> (node, parent) {
+          defined_fragments = node.definitions.select { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+        }
 
-  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
+        v[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
+          used_fragments << node
+          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) }
+      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)
-    end
-  end
+      private
 
-  def find_difference(fragments, allowed_fragment_names)
-    fragments.select {|f| !allowed_fragment_names.include?(f.name) }
+      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)
+        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/required_arguments_are_present.rb

@@ -1,34 +1,38 @@
-class GraphQL::StaticValidation::RequiredArgumentsArePresent
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    class RequiredArgumentsArePresent
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  def validate(context)
-    v = context.visitor
-    v[GraphQL::Language::Nodes::Field] << -> (node, parent) { validate_field(node, context) }
-    v[GraphQL::Language::Nodes::Directive] << -> (node, parent) { validate_directive(node, context) }
-  end
+      def validate(context)
+        v = context.visitor
+        v[GraphQL::Language::Nodes::Field] << -> (node, parent) { validate_field(node, context) }
+        v[GraphQL::Language::Nodes::Directive] << -> (node, parent) { validate_directive(node, context) }
+      end
 
-  private
+      private
 
-  def validate_directive(ast_directive, context)
-    directive_defn = context.schema.directives[ast_directive.name]
-    assert_required_args(ast_directive, directive_defn, context)
-  end
+      def validate_directive(ast_directive, context)
+        directive_defn = context.schema.directives[ast_directive.name]
+        assert_required_args(ast_directive, directive_defn, context)
+      end
 
-  def validate_field(ast_field, context)
-    return if context.skip_field?(ast_field.name)
-    defn = context.field_definition
-    assert_required_args(ast_field, defn, context)
-  end
+      def validate_field(ast_field, context)
+        return if context.skip_field?(ast_field.name)
+        defn = context.field_definition
+        assert_required_args(ast_field, defn, context)
+      end
 
-  def assert_required_args(ast_node, defn, context)
-    present_argument_names = ast_node.arguments.map(&:name)
-    required_argument_names = defn.arguments.values
-      .select { |a| a.type.kind.non_null? }
-      .map(&:name)
+      def assert_required_args(ast_node, defn, context)
+        present_argument_names = ast_node.arguments.map(&:name)
+        required_argument_names = defn.arguments.values
+          .select { |a| a.type.kind.non_null? }
+          .map(&:name)
 
-    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)
+        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)
+        end
+      end
     end
   end
 end

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

@@ -1,23 +1,27 @@
-class GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    class VariableDefaultValuesAreCorrectlyTyped
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  def validate(context)
-    literal_validator = GraphQL::StaticValidation::LiteralValidator.new
-    context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
-      if !node.default_value.nil?
-        validate_default_value(node, literal_validator, context)
+      def validate(context)
+        literal_validator = GraphQL::StaticValidation::LiteralValidator.new
+        context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
+          if !node.default_value.nil?
+            validate_default_value(node, literal_validator, context)
+          end
+        }
       end
-    }
-  end
 
-  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)
-    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)
+      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)
+        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)
+          end
+        end
       end
     end
   end

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

@@ -1,86 +1,95 @@
-class GraphQL::StaticValidation::VariableUsagesAreAllowed
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    class VariableUsagesAreAllowed
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  def validate(context)
-    # holds { name => ast_node } pairs
-    declared_variables = {}
+      def validate(context)
+        # holds { name => ast_node } pairs
+        declared_variables = {}
 
-    context.visitor[GraphQL::Language::Nodes::OperationDefinition] << -> (node, parent) {
-      declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
-    }
+        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << -> (node, parent) {
+          declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
+        }
 
-    context.visitor[GraphQL::Language::Nodes::Argument] << -> (node, parent) {
-      return if !node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-      if parent.is_a?(GraphQL::Language::Nodes::Field)
-        arguments = context.field_definition.arguments
-      elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
-        arguments = context.directive_definition.arguments
-      elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-        arguments = context.argument_definition.type.unwrap.input_fields
-      else
-        raise("Unexpected argument parent: #{parent}")
+        context.visitor[GraphQL::Language::Nodes::Argument] << -> (node, parent) {
+          return if !node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          if parent.is_a?(GraphQL::Language::Nodes::Field)
+            arguments = context.field_definition.arguments
+          elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
+            arguments = context.directive_definition.arguments
+          elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
+            arguments = context.argument_definition.type.unwrap.input_fields
+          else
+            raise("Unexpected argument parent: #{parent}")
+          end
+          var_defn_ast = declared_variables[node.value.name]
+          # Might be undefined :(
+          # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
+          var_defn_ast && validate_usage(arguments, node, var_defn_ast, context)
+        }
       end
-      var_defn_ast = declared_variables[node.value.name]
-      # Might be undefined :(
-      # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
-      var_defn_ast && validate_usage(arguments, node, var_defn_ast, context)
-    }
-  end
 
-  private
+      private
 
-  def validate_usage(arguments, arg_node, ast_var, context)
-    var_type = to_query_type(ast_var.type, context.schema.types)
-    if !ast_var.default_value.nil?
-      var_type = GraphQL::NonNullType.new(of_type: var_type)
-    end
+      def validate_usage(arguments, arg_node, ast_var, context)
+        var_type = to_query_type(ast_var.type, context.schema.types)
+        if !ast_var.default_value.nil?
+          var_type = GraphQL::NonNullType.new(of_type: var_type)
+        end
 
-    arg_defn = arguments[arg_node.name]
-    arg_defn_type = arg_defn.type
+        arg_defn = arguments[arg_node.name]
+        arg_defn_type = arg_defn.type
 
-    var_inner_type = var_type.unwrap
-    arg_inner_type = arg_defn_type.unwrap
+        var_inner_type = var_type.unwrap
+        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)
-    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)
-    elsif !non_null_levels_match(arg_defn_type, var_type)
-      context.errors << create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
-    end
-  end
+        if var_inner_type != arg_inner_type
+          context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node)
+        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)
+        elsif !non_null_levels_match(arg_defn_type, var_type)
+          context.errors << create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
+        end
+      end
 
-  def to_query_type(ast_type, types)
-    if ast_type.is_a?(GraphQL::Language::Nodes::NonNullType)
-      GraphQL::NonNullType.new(of_type: to_query_type(ast_type.of_type, types))
-    elsif ast_type.is_a?(GraphQL::Language::Nodes::ListType)
-      GraphQL::ListType.new(of_type: to_query_type(ast_type.of_type, types))
-    else
-      types[ast_type.name]
-    end
-  end
+      def to_query_type(ast_type, types)
+        if ast_type.is_a?(GraphQL::Language::Nodes::NonNullType)
+          GraphQL::NonNullType.new(of_type: to_query_type(ast_type.of_type, types))
+        elsif ast_type.is_a?(GraphQL::Language::Nodes::ListType)
+          GraphQL::ListType.new(of_type: to_query_type(ast_type.of_type, types))
+        else
+          types[ast_type.name]
+        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)
-  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)
+      end
 
-  def list_dimension(type)
-    if type.kind.list?
-      1 + list_dimension(type.of_type)
-    elsif type.kind.non_null?
-      list_dimension(type.of_type)
-    else
-      0
-    end
-  end
+      def list_dimension(type)
+        if type.kind.list?
+          1 + list_dimension(type.of_type)
+        elsif type.kind.non_null?
+          list_dimension(type.of_type)
+        else
+          0
+        end
+      end
 
-  def non_null_levels_match(arg_type, var_type)
-    if arg_type.kind.non_null? && !var_type.kind.non_null?
-      false
-    elsif arg_type.kind.wraps? && var_type.kind.wraps?
-      non_null_levels_match(arg_type.of_type, var_type.of_type)
-    else
-      true
+      def non_null_levels_match(arg_type, var_type)
+        if arg_type.kind.non_null? && !var_type.kind.non_null?
+          false
+        elsif arg_type.kind.wraps? && var_type.kind.wraps?
+          # If var_type is a non-null wrapper for a type, and arg_type is nullable, peel off the wrapper
+          # That way, a var_type of `[DairyAnimal]!` works with an arg_type of `[DairyAnimal]`
+          if var_type.kind.non_null? && !arg_type.kind.non_null?
+            var_type = var_type.of_type
+          end
+          non_null_levels_match(arg_type.of_type, var_type.of_type)
+        else
+          true
+        end
+      end
     end
   end
 end