graphql 0.0.4 → 0.1.0

data/lib/graph_ql/parser/nodes.rb

@@ -0,0 +1,72 @@
+module GraphQL::Nodes
+  # AbstractNode creates classes who:
+  # - require their keyword arguments, throw ArgumentError if they don't match
+  # - expose accessors for keyword arguments
+  class AbstractNode
+    def initialize(options)
+      required_keys = self.class.required_attrs
+
+      extra_keys = options.keys - required_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)
+        end
+      end
+    end
+
+    def children
+      self.class.required_attrs
+        .map { |attr| send(attr) }
+        .flatten # eg #fields is a list of children
+        .select { |val| val.is_a?(GraphQL::Nodes::AbstractNode) }
+    end
+
+    class << self
+      attr_reader :required_attrs
+      def attr_required(*attr_names)
+        @required_attrs ||= []
+        @required_attrs += attr_names
+        attr_accessor(*attr_names)
+      end
+
+      # Create a new AbstractNode child which
+      # requires and exposes {attr_names}.
+      def create(*attr_names, &block)
+        cls = Class.new(self, &block)
+        cls.attr_required(*attr_names)
+        cls
+      end
+    end
+  end
+
+  Argument = AbstractNode.create(:name, :value)
+  Directive = AbstractNode.create(:name, :arguments)
+  Document = AbstractNode.create(:parts)
+  Enum = AbstractNode.create(:name)
+  Field = AbstractNode.create(:name, :alias, :arguments, :directives, :selections)
+  FragmentDefinition = AbstractNode.create(:name, :type, :directives, :selections)
+  FragmentSpread = AbstractNode.create(:name, :directives)
+  InlineFragment = AbstractNode.create(:type, :directives, :selections)
+  InputObject = AbstractNode.create(:pairs) do
+    def to_h(options={})
+      pairs.inject({}) do |memo, pair|
+        v = pair.value
+        memo[pair.name] = v.is_a?(InputObject) ? v.to_h : v
+        memo
+      end
+    end
+  end
+  ListType = AbstractNode.create(:of_type)
+  NonNullType = AbstractNode.create(:of_type)
+  OperationDefinition = AbstractNode.create(:operation_type, :name, :variables, :directives, :selections)
+  TypeName = AbstractNode.create(:name)
+  Variable = AbstractNode.create(:name, :type, :default_value)
+  VariableIdentifier = AbstractNode.create(:name)
+end

data/lib/graph_ql/parser/parser.rb

@@ -0,0 +1,108 @@
+# Parser is a [parslet](http://kschiess.github.io/parslet/) parser for parsing queries.
+#
+# If it failes to parse, a {SyntaxError} is raised.
+class GraphQL::Parser < Parslet::Parser
+  root(:document)
+  rule(:document) { (
+      space                |
+      operation_definition |
+      fragment_definition
+    ).repeat(1).as(:document_parts)
+  }
+
+  # TODO: whitespace sensitive regarding `on`, eg `onFood`, see lookahead note in spec
+  rule(:fragment_definition) {
+    str("fragment") >>
+     space? >> name.as(:fragment_name) >>
+     space? >> str("on") >> space? >> name.as(:type_condition) >>
+     space? >> directives.maybe.as(:optional_directives).as(:directives) >>
+     space? >> selections.as(:selections)
+  }
+
+  rule(:fragment_spread) {
+    str("...") >> space? >>
+    name.as(:fragment_spread_name) >> space? >>
+    directives.maybe.as(:optional_directives).as(:directives)
+  }
+
+  # TODO: `on` bug, see spec
+  rule(:inline_fragment) {
+    str("...") >> space? >>
+    str("on ") >> name.as(:inline_fragment_type) >> space? >>
+    directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+    selections.as(:selections)
+  }
+
+  rule(:operation_definition) { (unnamed_selections | named_operation_definition) }
+  rule(:unnamed_selections) { selections.as(:unnamed_selections)}
+  rule(:named_operation_definition) {
+    operation_type.as(:operation_type) >> space? >>
+    name.as(:name) >>
+    operation_variable_definitions.maybe.as(:optional_variables).as(:variables) >> space? >>
+    directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+    selections.as(:selections)
+  }
+  rule(:operation_type) { (str("query") | str("mutation")) }
+  rule(:operation_variable_definitions) { str("(") >> space? >> (operation_variable_definition >> separator?).repeat(1) >> space? >> str(")") }
+  rule(:operation_variable_definition) {
+    value_variable.as(:variable_name) >> space? >>
+    str(":") >> space? >>
+    type.as(:variable_type) >> space? >>
+    (str("=") >> space? >> value.as(:variable_default_value)).maybe.as(:variable_optional_default_value)}
+
+  rule(:selection) { (inline_fragment | fragment_spread | field) >> space? >> separator? }
+  rule(:selections) { str("{") >> space? >> selection.repeat(1) >> space? >> str("}")}
+
+  rule(:field) {
+    field_alias.maybe.as(:alias) >>
+    name.as(:field_name) >>
+    field_arguments.maybe.as(:optional_field_arguments).as(:field_arguments) >> space? >>
+    directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+    selections.maybe.as(:optional_selections).as(:selections)
+  }
+
+  rule(:field_alias) { name.as(:alias_name) >> space? >> str(":") >> space? }
+  rule(:field_arguments) { str("(") >> field_argument.repeat(1) >> str(")") }
+  rule(:field_argument) { name.as(:field_argument_name) >> str(":") >> space? >> value.as(:field_argument_value) >> separator? }
+
+  rule(:directives) { (directive >> separator?).repeat(1) }
+  rule(:directive) {
+    str("@") >> name.as(:directive_name) >>
+    directive_arguments.maybe.as(:optional_directive_arguments).as(:directive_arguments)
+  }
+  rule(:directive_arguments) { str("(") >> directive_argument.repeat(1) >> str(")") }
+  rule(:directive_argument) { name.as(:directive_argument_name) >> str(":") >> space? >> value.as(:directive_argument_value) >> separator? }
+
+  rule(:type) { (non_null_type | list_type | type_name)}
+  rule(:list_type) { str("[") >> type.as(:list_type) >> str("]")}
+  rule(:non_null_type) { (list_type | type_name).as(:non_null_type) >> str("!") }
+  rule(:type_name) { name.as(:type_name) }
+
+  rule(:value) {(
+    value_input_object  |
+    value_float         |
+    value_int           |
+    value_string        |
+    value_boolean       |
+    value_array         |
+    value_variable      |
+    value_enum
+  )}
+  rule(:value_sign?) { str("-").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_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) }
+  # TODO: support unicode, escaped chars (match the spec)
+  rule(:value_string) { str('"') >> match('[^\"]').repeat(1).as(:string) >> str('"')}
+  rule(:value_enum) { name.as(:enum) }
+  rule(:value_variable) { str("$") >> name.as(:variable) }
+
+  rule(:separator?) { (space? >> str(",") >> space?).maybe }
+  rule(:name) { match('[_A-Za-z]') >> match('[_0-9A-Za-z]').repeat(0) }
+  rule(:comment) { str("#") >> match('[^\r\n]').repeat(0) }
+  rule(:space) { (match('[\s\n]+') | comment).repeat(1) }
+  rule(:space?) { space.maybe }
+end

data/lib/graph_ql/parser/transform.rb

@@ -0,0 +1,86 @@
+# {Transform} is a [parslet](http://kschiess.github.io/parslet/) transform for for turning the AST into objects in {GraphQL::Nodes} objects.
+class GraphQL::Transform < Parslet::Transform
+  # Get syntax classes by shallow name:
+  def self.const_missing(constant_name)
+    GraphQL::Nodes.const_get(constant_name)
+  end
+
+  def self.optional_sequence(name)
+    rule(name => simple(:val)) { [] }
+    rule(name => sequence(:val)) { val }
+  end
+
+  # Document
+  rule(document_parts: sequence(:p)) { Document.new(parts: p)}
+
+  # Fragment Definition
+  rule(
+    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)}
+
+  rule(
+    fragment_spread_name: simple(:n),
+    directives:           sequence(:d)
+  ) { FragmentSpread.new(name: n.to_s, directives: d)}
+
+  rule(
+    inline_fragment_type: simple(:n),
+    directives: sequence(:d),
+    selections: sequence(:s),
+  ) { InlineFragment.new(type: n.to_s, directives: d, selections: s)}
+
+  # Operation Definition
+  rule(
+    operation_type: simple(:ot),
+    name:           simple(:n),
+    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) }
+  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_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: [])}
+
+  # Field
+  rule(
+    alias: simple(:a),
+    field_name: simple(:name),
+    field_arguments: sequence(:args),
+    directives: sequence(:dir),
+    selections: sequence(:sel)
+  ) { Field.new(alias: a, name: name.to_s, arguments: args, directives: dir, selections: sel) }
+
+  rule(alias_name: simple(:a)) { a.to_s }
+  optional_sequence(:optional_field_arguments)
+  rule(field_argument_name: simple(:n), field_argument_value: simple(:v)) { Argument.new(name: n.to_s, value: v)}
+  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)}
+  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)}
+
+  # 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(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)}
+end

data/lib/graph_ql/parser/visitor.rb

@@ -0,0 +1,47 @@
+# Depth-first traversal through the tree, calling hooks at each stop.
+#
+# @example: Create a visitor, add hooks, then search a document
+#   total_field_count = 0
+#   visitor = GraphQL::Visitor.new
+#   visitor[GraphQL::Nodes::Field] << -> (node) { total_field_count += 1 }
+#   visitor[GraphQL::Nodes::Document].leave << -> (node) { p total_field_count }
+#   visitor.visit(document)
+#   # => 6
+#
+class GraphQL::Visitor
+  def initialize
+    @visitors = {}
+  end
+
+  def [](node_class)
+    @visitors[node_class] ||= NodeVisitor.new
+  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)
+  end
+
+  class NodeVisitor
+    attr_reader :enter, :leave
+    def initialize
+      @enter = []
+      @leave = []
+    end
+
+    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

@@ -0,0 +1,50 @@
+class GraphQL::Query
+  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: {})
+    @schema = schema
+    @document = GraphQL.parse(query_string)
+    @context = context
+    @params = params
+    @fragments = {}
+    @operations = {}
+
+    @document.parts.each do |part|
+      if part.is_a?(GraphQL::Nodes::FragmentDefinition)
+        @fragments[part.name] = part
+      elsif part.is_a?(GraphQL::Nodes::OperationDefinition)
+        @operations[part.name] = part
+      end
+    end
+  end
+
+  # Get the result for this query, executing it once
+  def result
+    @result ||= {
+      "data" => execute,
+    }
+  rescue StandardError => err
+    message = "Something went wrong during query execution: #{err}"
+    {"errors" => [{"message" => message}]}
+  end
+
+  private
+
+  def execute
+    response = {}
+    @operations.each do |name, operation|
+      resolver = OperationResolver.new(operation, self)
+      response[name] = resolver.result
+    end
+    response
+  end
+end

data/lib/graph_ql/query/arguments.rb

@@ -0,0 +1,25 @@
+# Creates a plain hash out of arguments, looking up variables if necessary
+class GraphQL::Query::Arguments
+  attr_reader :to_h
+  def initialize(ast_arguments, variables)
+    @to_h = ast_arguments.reduce({}) do |memo, arg|
+      value = reduce_value(arg.value, variables)
+      memo[arg.name] = value
+      memo
+    end
+  end
+
+  private
+
+  def reduce_value(value, variables)
+    if value.is_a?(GraphQL::Nodes::VariableIdentifier)
+      value = variables[value.name]
+    elsif value.is_a?(GraphQL::Nodes::Enum)
+      value = value.name
+    elsif value.is_a?(GraphQL::Nodes::InputObject)
+      value = self.class.new(value.pairs, variables).to_h
+    else
+      value
+    end
+  end
+end

data/lib/graph_ql/query/field_resolution_strategy.rb

@@ -0,0 +1,83 @@
+class GraphQL::Query::FieldResolutionStrategy
+  attr_reader :result, :result_value
+
+  def initialize(ast_field, parent_type, target, operation_resolver)
+    arguments = GraphQL::Query::Arguments.new(ast_field.arguments, operation_resolver.variables).to_h
+    field_name = ast_field.name
+    field = parent_type.fields[field_name] || raise("No field found on #{parent_type.name} '#{parent_type}' for '#{field_name}'")
+    value = field.resolve(target, arguments, operation_resolver.context)
+    if value.nil?
+      @result_value = value
+    else
+      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)")
+        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)
+      @result_value = result_strategy.result
+    end
+    result_name = ast_field.alias || ast_field.name
+    @result = { result_name => @result_value}
+  end
+
+  class ScalarResolutionStrategy
+    attr_reader :result
+    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
+      @result = field_type.coerce(value)
+    end
+  end
+
+  class ListResolutionStrategy
+    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]
+      @result = value.map do |item|
+        inner_strategy = strategy_class.new(item, wrapped_type, target, parent_type, ast_field, operation_resolver)
+        inner_strategy.result
+      end
+    end
+  end
+
+  class ObjectResolutionStrategy
+    attr_reader :result
+    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
+      resolver = GraphQL::Query::SelectionResolver.new(value, field_type, ast_field.selections, operation_resolver)
+      @result = resolver.result
+    end
+  end
+
+
+  class EnumResolutionStrategy
+    attr_reader :result
+    def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
+      @result = value.to_s
+    end
+  end
+
+  class NonNullResolutionStrategy
+    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)
+      @result = inner_strategy.result
+    end
+  end
+
+  private
+
+  FIELD_TYPE_KIND_STRATEGIES = {
+    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,
+  }
+end