graphql 0.1.0 → 0.2.0

data/lib/graph_ql/introspection/typename_field.rb

@@ -0,0 +1,15 @@
+# A wrapper to create `__typename`.
+# Uses `.create` because I couldn't figure out how to
+# pass `DEFINITION` via `super` (then I could extend GraphQL::Field)
+class GraphQL::Introspection::TypenameField
+  DEFINITION = Proc.new { |f, wrapped_type|
+    f.name "__typename"
+    f.description "The name of this type"
+    f.type -> { !GraphQL::STRING_TYPE }
+    f.resolve -> (obj, a, c) { wrapped_type.name }
+  }
+
+  def self.create(wrapped_type)
+     GraphQL::Field.new { |f| DEFINITION.call(f, wrapped_type) }
+  end
+end

data/lib/graph_ql/parser.rb

@@ -0,0 +1,9 @@
+require 'graph_ql/parser/nodes'
+require 'graph_ql/parser/parser'
+require 'graph_ql/parser/transform'
+require 'graph_ql/parser/visitor'
+
+module GraphQL
+  PARSER = GraphQL::Parser.new
+  TRANSFORM = GraphQL::Transform.new
+end

data/lib/graph_ql/parser/nodes.rb

@@ -3,20 +3,30 @@ module GraphQL::Nodes
   # - require their keyword arguments, throw ArgumentError if they don't match
   # - expose accessors for keyword arguments
   class AbstractNode
+    attr_accessor :line, :col
     def initialize(options)
       required_keys = self.class.required_attrs
+      allowed_keys = required_keys + [:line, :col]
+      position_source = options.delete(:position_source)
+      if !position_source.nil?
+        options[:line], options[:col] = position_source.line_and_column
+      end
 
-      extra_keys = options.keys - required_keys
+      present_keys = options.keys
+      extra_keys = present_keys - allowed_keys
       if extra_keys.any?
         raise ArgumentError, "#{self.class.name} Extra arguments: #{extra_keys}"
       end
 
-      required_keys.each do |attr|
-        if !options.has_key?(attr)
-          raise ArgumentError, "#{self.class.name} Missing argument: #{attr}"
-        else
-          value = options[attr]
-          self.send("#{attr}=", value)
+      missing_keys = required_keys - present_keys
+      if missing_keys.any?
+        raise ArgumentError, "#{self.class.name} Missing arguments: #{missing_keys}"
+      end
+
+      allowed_keys.each do |key|
+        if options.has_key?(key)
+          value = options[key]
+          self.send("#{key}=", value)
         end
       end
     end

data/lib/graph_ql/parser/parser.rb

@@ -12,7 +12,7 @@ class GraphQL::Parser < Parslet::Parser
 
   # TODO: whitespace sensitive regarding `on`, eg `onFood`, see lookahead note in spec
   rule(:fragment_definition) {
-    str("fragment") >>
+    str("fragment").as(:fragment_keyword) >>
      space? >> name.as(:fragment_name) >>
      space? >> str("on") >> space? >> name.as(:type_condition) >>
      space? >> directives.maybe.as(:optional_directives).as(:directives) >>
@@ -20,14 +20,14 @@ class GraphQL::Parser < Parslet::Parser
   }
 
   rule(:fragment_spread) {
-    str("...") >> space? >>
+    spread.as(:fragment_spread_keyword) >> space? >>
     name.as(:fragment_spread_name) >> space? >>
     directives.maybe.as(:optional_directives).as(:directives)
   }
-
+  rule(:spread) { str("...") }
   # TODO: `on` bug, see spec
   rule(:inline_fragment) {
-    str("...") >> space? >>
+    spread.as(:fragment_spread_keyword) >> space? >>
     str("on ") >> name.as(:inline_fragment_type) >> space? >>
     directives.maybe.as(:optional_directives).as(:directives) >> space? >>
     selections.as(:selections)
@@ -37,7 +37,7 @@ class GraphQL::Parser < Parslet::Parser
   rule(:unnamed_selections) { selections.as(:unnamed_selections)}
   rule(:named_operation_definition) {
     operation_type.as(:operation_type) >> space? >>
-    name.as(:name) >>
+    name.as(:name) >> space? >>
     operation_variable_definitions.maybe.as(:optional_variables).as(:variables) >> space? >>
     directives.maybe.as(:optional_directives).as(:directives) >> space? >>
     selections.as(:selections)
@@ -88,10 +88,10 @@ class GraphQL::Parser < Parslet::Parser
     value_variable      |
     value_enum
   )}
-  rule(:value_sign?) { str("-").maybe }
+  rule(:value_sign?) { match('[\-\+]').maybe }
   rule(:value_array) { (str("[") >> (value >> separator?).repeat(0) >> str("]")).as(:array) }
   rule(:value_boolean) { (str("true") | str("false")).as(:boolean) }
-  rule(:value_float) { (value_sign? >> match('\d').repeat(1) >> str(".") >> match('\d').repeat(1) >> (str("e") >> value_sign? >> match('\d').repeat(1)).maybe).as(:float) }
+  rule(:value_float) { (value_sign? >> match('\d').repeat(1) >> str(".") >> match('\d').repeat(1) >> (match("[eE]") >> value_sign? >> match('\d').repeat(1)).maybe).as(:float) }
   rule(:value_input_object) { str("{") >> value_input_object_pair.repeat(1).as(:input_object) >> str("}") }
   rule(:value_input_object_pair) { space? >> name.as(:input_object_name) >>  space? >> str(":") >> space? >> value.as(:input_object_value) >> separator? }
   rule(:value_int) { (value_sign? >> match('\d').repeat(1)).as(:int) }

data/lib/graph_ql/parser/transform.rb

@@ -11,26 +11,29 @@ class GraphQL::Transform < Parslet::Transform
   end
 
   # Document
-  rule(document_parts: sequence(:p)) { Document.new(parts: p)}
+  rule(document_parts: sequence(:p)) { Document.new(parts: p, line: p.first.line, col: p.first.col)}
 
   # Fragment Definition
   rule(
+    fragment_keyword: simple(:kw),
     fragment_name:  simple(:name),
     type_condition: simple(:type),
     directives:     sequence(:directives),
     selections:     sequence(:selections)
-  ) {FragmentDefinition.new(name: name.to_s, type: type.to_s, directives: directives, selections: selections)}
+  ) {FragmentDefinition.new(name: name.to_s, type: type.to_s, directives: directives, selections: selections, position_source: kw)}
 
   rule(
+    fragment_spread_keyword: simple(:kw),
     fragment_spread_name: simple(:n),
     directives:           sequence(:d)
-  ) { FragmentSpread.new(name: n.to_s, directives: d)}
+  ) { FragmentSpread.new(name: n.to_s, directives: d, position_source: kw)}
 
   rule(
+    fragment_spread_keyword: simple(:kw),
     inline_fragment_type: simple(:n),
     directives: sequence(:d),
     selections: sequence(:s),
-  ) { InlineFragment.new(type: n.to_s, directives: d, selections: s)}
+  ) { InlineFragment.new(type: n.to_s, directives: d, selections: s, position_source: kw)}
 
   # Operation Definition
   rule(
@@ -39,14 +42,14 @@ class GraphQL::Transform < Parslet::Transform
     variables:      sequence(:v),
     directives:     sequence(:d),
     selections:     sequence(:s),
-  ) { OperationDefinition.new(operation_type: ot.to_s, name: n.to_s, variables: v, directives: d, selections: s) }
+  ) { OperationDefinition.new(operation_type: ot.to_s, name: n.to_s, variables: v, directives: d, selections: s, position_source: ot) }
   optional_sequence(:optional_variables)
-  rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: simple(:v)) { Variable.new(name: n.name, type: t, default_value: v)}
-  rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: sequence(:v)) { Variable.new(name: n.name, type: t, default_value: v)}
+  rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: simple(:v)) { Variable.new(name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
+  rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: sequence(:v)) { Variable.new(name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
   rule(variable_default_value: simple(:v) ) { v }
   rule(variable_default_value: sequence(:v) ) { v }
   # Query short-hand
-  rule(unnamed_selections: sequence(:s)) { OperationDefinition.new(selections: s, operation_type: "query", name: nil, variables: [], directives: [])}
+  rule(unnamed_selections: sequence(:s)) { OperationDefinition.new(selections: s, operation_type: "query", name: nil, variables: [], directives: [], line: s.first.line, col: s.first.col)}
 
   # Field
   rule(
@@ -55,32 +58,32 @@ class GraphQL::Transform < Parslet::Transform
     field_arguments: sequence(:args),
     directives: sequence(:dir),
     selections: sequence(:sel)
-  ) { Field.new(alias: a, name: name.to_s, arguments: args, directives: dir, selections: sel) }
+  ) { Field.new(alias: a && a.to_s, name: name.to_s, arguments: args, directives: dir, selections: sel, position_source: [a, name].find { |part| !part.nil? }) }
 
-  rule(alias_name: simple(:a)) { a.to_s }
+  rule(alias_name: simple(:a)) { a }
   optional_sequence(:optional_field_arguments)
-  rule(field_argument_name: simple(:n), field_argument_value: simple(:v)) { Argument.new(name: n.to_s, value: v)}
+  rule(field_argument_name: simple(:n), field_argument_value: simple(:v)) { Argument.new(name: n.to_s, value: v, position_source: n)}
   optional_sequence(:optional_selections)
   optional_sequence(:optional_directives)
 
   # Directive
-  rule(directive_name: simple(:name), directive_arguments: sequence(:args)) { Directive.new(name: name.to_s, arguments: args) }
-  rule(directive_argument_name: simple(:n), directive_argument_value: simple(:v)) { Argument.new(name: n.to_s, value: v)}
+  rule(directive_name: simple(:name), directive_arguments: sequence(:args)) { Directive.new(name: name.to_s, arguments: args, position_source: name ) }
+  rule(directive_argument_name: simple(:n), directive_argument_value: simple(:v)) { Argument.new(name: n.to_s, value: v, position_source: n)}
   optional_sequence(:optional_directive_arguments)
 
   # Type Defs
-  rule(type_name: simple(:n))     { TypeName.new(name: n.to_s) }
-  rule(list_type: simple(:t))     { ListType.new(of_type: t)}
-  rule(non_null_type: simple(:t)) { NonNullType.new(of_type: t)}
+  rule(type_name: simple(:n))     { TypeName.new(name: n.to_s, position_source: n) }
+  rule(list_type: simple(:t))     { ListType.new(of_type: t, line: t.line, col: t.col)}
+  rule(non_null_type: simple(:t)) { NonNullType.new(of_type: t, line: t.line, col: t.col)}
 
   # Values
   rule(array: sequence(:v)) { v }
   rule(boolean: simple(:v)) { v == "true" ? true : false }
-  rule(input_object: sequence(:v)) { InputObject.new(pairs: v) }
-  rule(input_object_name: simple(:n), input_object_value: simple(:v)) { Argument.new(name: n.to_s, value: v)}
+  rule(input_object: sequence(:v)) { InputObject.new(pairs: v, line: v.first.line, col: v.first.col) }
+  rule(input_object_name: simple(:n), input_object_value: simple(:v)) { Argument.new(name: n.to_s, value: v, position_source: n)}
   rule(int: simple(:v)) { v.to_i }
   rule(float: simple(:v)) { v.to_f }
   rule(string: simple(:v)) { v.to_s }
-  rule(variable: simple(:v)) { VariableIdentifier.new(name: v.to_s) }
-  rule(enum: simple(:v)) { Enum.new(name: v.to_s)}
+  rule(variable: simple(:v)) { VariableIdentifier.new(name: v.to_s, position_source: v) }
+  rule(enum: simple(:v)) { Enum.new(name: v.to_s, position_source: v)}
 end

data/lib/graph_ql/parser/visitor.rb

@@ -9,8 +9,13 @@
 #   # => 6
 #
 class GraphQL::Visitor
+  SKIP = :_skip
+
+  attr_reader :enter, :leave
   def initialize
     @visitors = {}
+    @enter = []
+    @leave = []
   end
 
   def [](node_class)
@@ -18,11 +23,30 @@ class GraphQL::Visitor
   end
 
   # Apply built-up vistors to `document`
-  def visit(root)
-    node_visitor = self[root.class]
-    node_visitor.begin_visit(root)
-    root.children.map { |child| visit(child) }
-    node_visitor.end_visit(root)
+  def visit(root, parent=nil)
+    begin_visit(root, parent) &&
+      root.children.reduce(true) { |memo, child| memo && visit(child, root) }
+    end_visit(root, parent)
+  end
+
+  private
+
+  def begin_visit(node, parent)
+    self.class.apply_hooks(enter, node, parent)
+    node_visitor = self[node.class]
+    self.class.apply_hooks(node_visitor.enter, node, parent)
+  end
+
+  # Should global `leave` visitors come first or last?
+  def end_visit(node, parent)
+    self.class.apply_hooks(leave, node, parent)
+    node_visitor = self[node.class]
+    self.class.apply_hooks(node_visitor.leave, node, parent)
+  end
+
+  # If one of the visitors returns SKIP, stop visiting this node
+  def self.apply_hooks(hooks, node, parent)
+    hooks.reduce(true) { |memo, proc| memo && (proc.call(node, parent) != SKIP) }
   end
 
   class NodeVisitor
@@ -35,13 +59,5 @@ class GraphQL::Visitor
     def <<(hook)
       enter << hook
     end
-
-    def begin_visit(node)
-      enter.map{ |proc| proc.call(node) }
-    end
-
-    def end_visit(node)
-      leave.map{ |proc| proc.call(node) }
-    end
   end
 end

data/lib/graph_ql/query.rb

@@ -1,23 +1,21 @@
 class GraphQL::Query
+  # If a resolve function returns `GraphQL::Query::DEFAULT_RESOLVE`,
+  # The executor will send the field's name to the target object
+  # and use the result.
   DEFAULT_RESOLVE = :__default_resolve
-  extend ActiveSupport::Autoload
-  autoload(:Arguments)
-  autoload(:FieldResolutionStrategy)
-  autoload(:FragmentSpreadResolutionStrategy)
-  autoload(:InlineFragmentResolutionStrategy)
-  autoload(:OperationResolver)
-  autoload(:SelectionResolver)
-  autoload(:TypeResolver)
   attr_reader :schema, :document, :context, :fragments, :params
 
-  def initialize(schema, query_string, context: nil, params: {})
+  def initialize(schema, query_string, context: nil, params: {}, debug: true, validate: true)
     @schema = schema
-    @document = GraphQL.parse(query_string)
+    @debug = debug
+    @query_string = query_string
     @context = context
     @params = params
+    @validate = validate
     @fragments = {}
     @operations = {}
 
+    @document = GraphQL.parse(@query_string)
     @document.parts.each do |part|
       if part.is_a?(GraphQL::Nodes::FragmentDefinition)
         @fragments[part.name] = part
@@ -29,22 +27,47 @@ class GraphQL::Query
 
   # Get the result for this query, executing it once
   def result
+    if validation_errors.any?
+      return { "errors" => validation_errors }
+    end
+
     @result ||= {
       "data" => execute,
     }
   rescue StandardError => err
-    message = "Something went wrong during query execution: #{err}"
-    {"errors" => [{"message" => message}]}
+    if @debug
+      raise err
+    else
+      message = "Something went wrong during query execution: #{err}" # \n  #{err.backtrace.join("\n  ")}"
+      {"errors" => [{"message" => message}]}
+    end
   end
 
   private
 
   def execute
-    response = {}
-    @operations.each do |name, operation|
+    @operations.reduce({}) do |memo, (name, operation)|
       resolver = OperationResolver.new(operation, self)
-      response[name] = resolver.result
+      memo[name] = resolver.result
+      memo
+    end
+  end
+
+  def validation_errors
+    @validation_errors ||= begin
+      if @validate
+        @schema.static_validator.validate(@document)
+      else
+        []
+      end
     end
-    response
   end
 end
+
+require 'graph_ql/query/arguments'
+require 'graph_ql/query/field_resolution_strategy'
+require 'graph_ql/query/fragment_spread_resolution_strategy'
+require 'graph_ql/query/inline_fragment_resolution_strategy'
+require 'graph_ql/query/operation_resolver'
+require 'graph_ql/query/selection_resolver'
+require 'graph_ql/query/type_resolver'

data/lib/graph_ql/query/field_resolution_strategy.rb

@@ -12,18 +12,23 @@ class GraphQL::Query::FieldResolutionStrategy
       if value == GraphQL::Query::DEFAULT_RESOLVE
         begin
           value = target.send(field_name)
-        rescue NoMethodError => e
-          raise("Couldn't resolve field '#{field_name}' to #{target.class} '#{target}' (resulted in NoMethodError)")
+        rescue NoMethodError => err
+          raise("Couldn't resolve field '#{field_name}' to #{target.class} '#{target}' (resulted in #{err})")
         end
       end
-      strategy_class = FIELD_TYPE_KIND_STRATEGIES[field.type.kind] || raise("No strategy found for #{field.type.kind}")
-      result_strategy = strategy_class.new(value, field.type, target, parent_type, ast_field, operation_resolver)
+      resolved_type = field.type.kind.resolve(field.type, value)
+      strategy_class = self.class.get_strategy_for_kind(resolved_type.kind)
+      result_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, operation_resolver)
       @result_value = result_strategy.result
     end
     result_name = ast_field.alias || ast_field.name
     @result = { result_name => @result_value}
   end
 
+  def self.get_strategy_for_kind(kind)
+    FIELD_TYPE_KIND_STRATEGIES[kind] || raise("No strategy for #{kind}")
+  end
+
   class ScalarResolutionStrategy
     attr_reader :result
     def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
@@ -35,9 +40,10 @@ class GraphQL::Query::FieldResolutionStrategy
     attr_reader :result
     def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
       wrapped_type = field_type.of_type
-      strategy_class = FIELD_TYPE_KIND_STRATEGIES[wrapped_type.kind]
+      resolved_type = wrapped_type.kind.resolve(wrapped_type, value)
+      strategy_class = GraphQL::Query::FieldResolutionStrategy.get_strategy_for_kind(resolved_type.kind)
       @result = value.map do |item|
-        inner_strategy = strategy_class.new(item, wrapped_type, target, parent_type, ast_field, operation_resolver)
+        inner_strategy = strategy_class.new(item, resolved_type, target, parent_type, ast_field, operation_resolver)
         inner_strategy.result
       end
     end
@@ -51,7 +57,6 @@ class GraphQL::Query::FieldResolutionStrategy
     end
   end
 
-
   class EnumResolutionStrategy
     attr_reader :result
     def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
@@ -63,8 +68,9 @@ class GraphQL::Query::FieldResolutionStrategy
     attr_reader :result
     def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
       wrapped_type = field_type.of_type
-      strategy_class = FIELD_TYPE_KIND_STRATEGIES[wrapped_type.kind]
-      inner_strategy = strategy_class.new(value, wrapped_type, target, parent_type, ast_field, operation_resolver)
+      resolved_type = wrapped_type.kind.resolve(wrapped_type, value)
+      strategy_class = GraphQL::Query::FieldResolutionStrategy.get_strategy_for_kind(resolved_type.kind)
+      inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, operation_resolver)
       @result = inner_strategy.result
     end
   end
@@ -75,8 +81,6 @@ class GraphQL::Query::FieldResolutionStrategy
     GraphQL::TypeKinds::SCALAR =>     ScalarResolutionStrategy,
     GraphQL::TypeKinds::LIST =>       ListResolutionStrategy,
     GraphQL::TypeKinds::OBJECT =>     ObjectResolutionStrategy,
-    GraphQL::TypeKinds::UNION =>      ObjectResolutionStrategy,
-    GraphQL::TypeKinds::INTERFACE =>  ObjectResolutionStrategy,
     GraphQL::TypeKinds::ENUM =>       EnumResolutionStrategy,
     GraphQL::TypeKinds::NON_NULL =>   NonNullResolutionStrategy,
   }

data/lib/graph_ql/query/type_resolver.rb

@@ -6,9 +6,11 @@ class GraphQL::Query::TypeResolver
   def initialize(target, child_type, parent_type)
     @type = if child_type.nil?
       nil
-    elsif GraphQL::TypeKinds::UNION == parent_type.kind
+    elsif parent_type.kind.union?
       parent_type.resolve_type(target)
-    elsif GraphQL::TypeKinds::INTERFACE == child_type.kind
+    elsif child_type.kind.union? && child_type.include?(parent_type)
+      parent_type
+    elsif child_type.kind.interface?
       child_type.resolve_type(target)
     elsif child_type == parent_type
       parent_type

data/lib/graph_ql/repl.rb

@@ -19,7 +19,7 @@ class GraphQL::Repl
   def execute_query(query_string)
     begin
       query = GraphQL::Query.new(@schema, query_string)
-      puts JSON.pretty_generate(query.execute)
+      puts JSON.pretty_generate(query.result)
     rescue StandardError => err
       puts "Couldn't parse: #{err}\n\n" # #{err.backtrace.join("\n")}"
     end