graphql 0.2.0 → 0.3.0

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

@@ -0,0 +1,23 @@
+class GraphQL::StaticValidation::FragmentsAreFinite
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    context.visitor[GraphQL::Nodes::FragmentDefinition] << -> (node, parent) {
+      if has_nested_spread(node, [], context)
+        context.errors << message("Fragment #{node.name} contains an infinite loop", node)
+      end
+    }
+  end
+
+  private
+
+  def has_nested_spread(fragment_def, parent_fragment_names, context)
+    nested_spreads = fragment_def.selections
+      .select {|f| f.is_a?(GraphQL::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/graph_ql/static_validation/rules/fragments_are_on_composite_types.rb

@@ -0,0 +1,27 @@
+class GraphQL::StaticValidation::FragmentsAreOnCompositeTypes
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  HAS_TYPE_CONDITION = [
+    GraphQL::Nodes::FragmentDefinition,
+    GraphQL::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
+
+  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::Visitor::SKIP
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+class GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    literal_validator = GraphQL::StaticValidation::LiteralValidator.new
+    context.visitor[GraphQL::Nodes::Variable] << -> (node, parent) {
+      if !node.default_value.nil?
+        validate_default_value(node, literal_validator, context)
+      end
+    }
+  end
+
+  def validate_default_value(node, literal_validator, context)
+    value = node.default_value
+    if node.type.is_a?(GraphQL::Nodes::NonNullType)
+      context.errors << message("Non-null variable $#{node.name} can't have a default value", node)
+    else
+      type = context.schema.types[node.type.name]
+      if !literal_validator.validate(value, type)
+        context.errors << message("Default value for $#{node.name} doesn't match type #{node.type.name}", node)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+class GraphQL::StaticValidation::VariableUsagesAreAllowed
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    # holds { name => ast_node } pairs
+    declared_variables = {}
+
+    context.visitor[GraphQL::Nodes::OperationDefinition] << -> (node, parent) {
+      declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
+    }
+
+    context.visitor[GraphQL::Nodes::Argument] << -> (node, parent) {
+      return if !node.value.is_a?(GraphQL::Nodes::VariableIdentifier)
+      if parent.is_a?(GraphQL::Nodes::Field)
+        arguments = context.field_definition.arguments
+      elsif parent.is_a?(GraphQL::Nodes::Directive)
+        arguments = context.directive_definition.arguments
+      end
+      var_defn_ast = declared_variables[node.value.name]
+      validate_usage(arguments, node, var_defn_ast, context)
+    }
+  end
+
+  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
+
+    arg_defn = arguments[arg_node.name]
+    if var_type != arg_defn.type
+      context.errors << message("Type mismatch on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node)
+    end
+  end
+
+  def to_query_type(ast_type, types)
+    if ast_type.is_a?(GraphQL::Nodes::NonNullType)
+      GraphQL::NonNullType.new(of_type: to_query_type(ast_type.of_type, types))
+    elsif ast_type.is_a?(GraphQL::Nodes::ListType)
+      GraphQL::ListType.new(of_type: to_query_type(ast_type.of_type, types))
+    else
+      types[ast_type.name]
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+class GraphQL::StaticValidation::VariablesAreInputTypes
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    context.visitor[GraphQL::Nodes::Variable] << -> (node, parent) {
+      validate_is_input_type(node, context)
+    }
+  end
+
+  private
+
+  def validate_is_input_type(node, context)
+    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)
+    end
+  end
+
+  def get_type_name(ast_type)
+    if ast_type.respond_to?(:of_type)
+      get_type_name(ast_type.of_type)
+    else
+      ast_type.name
+    end
+  end
+end

data/lib/graph_ql/static_validation/rules/variables_are_used_and_defined.rb

@@ -0,0 +1,31 @@
+class GraphQL::StaticValidation::VariablesAreUsedAndDefined
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    # holds { name => used? } pairs
+    declared_variables = {}
+
+    context.visitor[GraphQL::Nodes::OperationDefinition] << -> (node, parent) {
+      declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = false }
+    }
+
+    context.visitor[GraphQL::Nodes::VariableIdentifier] << -> (node, parent) {
+      if declared_variables.key?(node.name)
+        declared_variables[node.name] = true
+      else
+        context.errors << message("Variable $#{node.name} is used but not declared", node)
+        GraphQL::Visitor::SKIP
+      end
+    }
+
+    context.visitor[GraphQL::Nodes::OperationDefinition].leave << -> (node, parent) {
+      unused_variables = declared_variables
+        .select { |name, used| !used }
+        .keys
+
+      unused_variables.each do |var_name|
+        context.errors << message("Variable $#{var_name} is declared but not used", node)
+      end
+    }
+  end
+end

data/lib/graph_ql/static_validation/type_stack.rb

@@ -7,11 +7,12 @@ class GraphQL::StaticValidation::TypeStack
     GraphQL::Nodes::FragmentDefinition,
   ]
 
-  attr_reader :schema, :object_types, :field_definitions
+  attr_reader :schema, :object_types, :field_definitions, :directive_definitions
   def initialize(schema, visitor)
     @schema = schema
     @object_types = []
     @field_definitions = []
+    @directive_definitions = []
     visitor.enter << -> (node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
     visitor.leave << -> (node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
   end
@@ -80,6 +81,17 @@ class GraphQL::StaticValidation::TypeStack
     end
   end
 
+  class DirectiveStrategy
+    def push(stack, node)
+      directive_defn = stack.schema.directives[node.name]
+      stack.directive_definitions.push(directive_defn)
+    end
+
+    def pop(stack, node)
+      stack.directive_definitions.pop
+    end
+  end
+
   class NullStrategy
     def push(stack, node);  end
     def pop(stack, node);   end

data/lib/graph_ql/static_validation/validator.rb

@@ -1,25 +1,16 @@
+# Initialized with a {GraphQL::Schema}, then it can validate {GraphQL::Nodes::Documents}s based on that schema.
+#
+# By default, it's used by {GraphQL::Query}
 class GraphQL::StaticValidation::Validator
-  VALIDATORS = [
-    GraphQL::StaticValidation::DirectivesAreDefined,
-    GraphQL::StaticValidation::ArgumentsAreDefined,
-    GraphQL::StaticValidation::RequiredArgumentsArePresent,
-    GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
-    GraphQL::StaticValidation::FragmentTypesExist,
-    GraphQL::StaticValidation::FragmentsAreUsed,
-    GraphQL::StaticValidation::FieldsAreDefinedOnType,
-    GraphQL::StaticValidation::FieldsWillMerge,
-    GraphQL::StaticValidation::FieldsHaveAppropriateSelections,
-  ]
-
-  def initialize(schema:, validators: VALIDATORS)
+  def initialize(schema:, rules: GraphQL::StaticValidation::ALL_RULES)
     @schema = schema
-    @validators = validators
+    @rules = rules
   end
 
   def validate(document)
     context = Context.new(@schema, document)
-    @validators.each do |validator|
-      validator.new.validate(context)
+    @rules.each do |rules|
+      rules.new.validate(context)
     end
     context.visitor.visit(document)
     context.errors.map(&:to_h)
@@ -30,10 +21,11 @@ class GraphQL::StaticValidation::Validator
     def initialize(schema, document)
       @schema = schema
       @document = document
-      @fragments = {}
+      @fragments = document.parts.each_with_object({}) do |part, memo|
+        part.is_a?(GraphQL::Nodes::FragmentDefinition) && memo[part.name] = part
+      end
       @errors = []
       @visitor = GraphQL::Visitor.new
-      @visitor[GraphQL::Nodes::FragmentDefinition] << -> (node, parent) { @fragments[node.name] = node }
       @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
     end
 
@@ -44,5 +36,9 @@ class GraphQL::StaticValidation::Validator
     def field_definition
       @type_stack.field_definitions.last
     end
+
+    def directive_definition
+      @type_stack.directive_definitions.last
+    end
   end
 end

data/lib/graph_ql/type_kinds.rb

@@ -1,17 +1,21 @@
 module GraphQL::TypeKinds
   class TypeKind
     attr_reader :name
-    def initialize(name, resolves: false, fields: false, wraps: false)
+    def initialize(name, resolves: false, fields: false, wraps: false, input: false)
       @name = name
       @resolves = resolves
       @fields = fields
       @wraps = wraps
+      @input = input
+      @composite = fields? || resolves?
     end
 
     def resolves?;  @resolves;  end
     def fields?;    @fields;    end
     def wraps?;     @wraps;     end
+    def input?;     @input;     end
     def to_s;       @name;      end
+    def composite?; @composite; end
 
     def resolve(type, value)
       if resolves?
@@ -32,12 +36,12 @@ module GraphQL::TypeKinds
   end
 
   TYPE_KINDS = [
-    SCALAR =        TypeKind.new("SCALAR"),
+    SCALAR =        TypeKind.new("SCALAR", input: true),
     OBJECT =        TypeKind.new("OBJECT", fields: true),
     INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true),
     UNION =         TypeKind.new("UNION", resolves: true),
-    ENUM =          TypeKind.new("ENUM"),
-    INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT"),
+    ENUM =          TypeKind.new("ENUM", input: true),
+    INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true),
     LIST =          TypeKind.new("LIST", wraps: true),
     NON_NULL =      TypeKind.new("NON_NULL", wraps: true),
   ]

data/lib/graph_ql/{enum.rb → types/enum.rb}

@@ -8,24 +8,25 @@ class GraphQL::Enum
     yield(self, GraphQL::TypeDefiner.instance, GraphQL::FieldDefiner.instance, GraphQL::ArgumentDefiner.instance)
   end
 
-  def value(name, description=nil, deprecation_reason: nil)
-    @values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason)
+  def value(name, description=nil, deprecation_reason: nil, value: name)
+    @values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
   end
 
   def kind
     GraphQL::TypeKinds::ENUM
   end
 
-  def coerce(value)
-    @values[value]
+  def coerce(value_name)
+    @values[value_name].value
   end
 
   class EnumValue
-    attr_reader :name, :description, :deprecation_reason
-    def initialize(name:, description:, deprecation_reason:)
+    attr_reader :name, :description, :deprecation_reason, :value
+    def initialize(name:, description:, deprecation_reason:, value:)
       @name = name
       @description = description
       @deprecation_reason = deprecation_reason
+      @value = value
     end
   end
 end

data/lib/graph_ql/types/input_object_type.rb

@@ -2,20 +2,13 @@ class GraphQL::InputObjectType < GraphQL::ObjectType
   attr_definable :input_fields
 
   def input_fields(new_fields=nil)
-    if new_fields.nil?
-      @new_fields
-    else
-      @new_fields = new_fields
-        .reduce({}) {|memo, (k, v)| memo[k.to_s] = v; memo}
-        .each { |k, v| v.respond_to?("name=") && v.name = k}
+    if !new_fields.nil?
+      @new_fields = GraphQL::StringNamedHash.new(new_fields).to_h
     end
+    @new_fields
   end
 
   def kind
     GraphQL::TypeKinds::INPUT_OBJECT
   end
-
-  def to_s
-    "<GraphQL::InputObjectType #{name}>"
-  end
 end

data/lib/graph_ql/{interface.rb → types/interface.rb}

@@ -11,8 +11,4 @@ class GraphQL::Interface < GraphQL::ObjectType
   def resolve_type(object)
     @possible_types.find {|t| t.name == object.class.name }
   end
-
-  def to_s
-    "<GraphQL::Interface #{name}>"
-  end
 end

data/lib/graph_ql/types/list_type.rb

@@ -7,8 +7,4 @@ class GraphQL::ListType < GraphQL::ObjectType
   def kind
     GraphQL::TypeKinds::LIST
   end
-
-  def to_s
-    "<GraphQL::ListType(#{of_type.name})>"
-  end
 end

data/lib/graph_ql/types/non_null_type.rb

@@ -15,8 +15,4 @@ class GraphQL::NonNullType < GraphQL::ObjectType
   def kind
     GraphQL::TypeKinds::NON_NULL
   end
-
-  def to_s
-    "<GraphQL::NonNullType(#{of_type.name})>"
-  end
 end

data/lib/graph_ql/types/object_type.rb

@@ -10,31 +10,27 @@ class GraphQL::ObjectType
   end
 
   def fields(new_fields=nil)
-    if new_fields
+    if !new_fields.nil?
       self.fields = new_fields
-    else
-      @fields
     end
+    @fields
   end
 
   def fields=(new_fields)
-    stringified_fields = new_fields
-      .reduce({}) { |memo, (key, value)| memo[key.to_s] = value; memo }
-    # Set the name from its context on this type:
-    stringified_fields.each {|k, v| v.respond_to?("name=") && v.name = k }
+    stringified_fields = GraphQL::StringNamedHash.new(new_fields).to_h
+    # TODO: should this field be exposed during introspection? https://github.com/graphql/graphql-js/issues/73
     stringified_fields["__typename"] = GraphQL::Introspection::TypenameField.create(self)
     @fields = stringified_fields
   end
 
   def interfaces(new_interfaces=nil)
-    if new_interfaces.nil?
-      @interfaces
-    else
+    if !new_interfaces.nil?
       # if you define interfaces twice, you're gonna have a bad time :(
       # (because it gets registered with that interface, then overriden)
       @interfaces = new_interfaces
       new_interfaces.each {|i| i.possible_types << self }
     end
+    @interfaces
   end
 
   def kind
@@ -42,10 +38,29 @@ class GraphQL::ObjectType
   end
 
   def to_s
-    "<GraphQL::ObjectType #{name}>"
+    Printer.instance.print(self)
+  end
+
+  alias :inspect :to_s
+
+  def ==(other)
+    if other.is_a?(GraphQL::ObjectType)
+      self.to_s == other.to_s
+    else
+      super
+    end
   end
 
-  def inspect
-    to_s
+  class Printer
+    include Singleton
+    def print(type)
+      if type.kind.non_null?
+        "#{print(type.of_type)}!"
+      elsif type.kind.list?
+        "[#{print(type.of_type)}]"
+      else
+        type.name
+      end
+    end
   end
 end