graphql 0.0.1 → 0.0.2

data/lib/graphql/node.rb

@@ -1,61 +1,168 @@
+# Node is the base class for your GraphQL nodes.
+# It's essentially a delegator that only delegates methods you whitelist with {.field}.
+# To use it:
+#
+# - Extend `GraphQL::Node`
+# - Declare what this node will wrap with {.exposes}
+# - Declare fields with {.field}
+#
+# @example
+#   class PostNode < GraphQL::Node
+#     exposes('Post')
+#
+#     cursor(:id)
+#
+#     field.number(:id)
+#     field.string(:title)
+#     field.string(:content)
+#     field.connection(:comments)
+#   end
+#
+
 class GraphQL::Node
-  attr_accessor :fields
+  # The object wrapped by this `Node`
+  attr_reader :target
+  # Fields parsed from the query string
+  attr_reader :syntax_fields
+  # The query to which this `Node` belongs. Used for accessing its {Query#context}.
+  attr_reader :query
 
-  def initialize(target=nil)
-    # DONT EXPOSE Node#target! otherwise you might be able to access it
+  def initialize(target=nil, fields:, query:)
     @target = target
+    @query = query
+    @syntax_fields = fields
   end
 
-  def safe_send(identifier)
-    if respond_to?(identifier)
-      public_send(identifier)
+  # If the target responds to `method_name`, send it to target.
+  def method_missing(method_name, *args, &block)
+    if target.respond_to?(method_name)
+      target.public_send(method_name, *args, &block)
     else
-      raise GraphQL::FieldNotDefinedError, "#{self.class.name}##{identifier} was requested, but it isn't defined."
+      super
     end
   end
 
-  def to_json
+  # Looks up {#syntax_fields} against this node and returns the results
+  def as_result
     json = {}
-    fields.each do |field|
-      name = field.identifier
-      if field.is_a?(GraphQL::Syntax::Field)
-        json[name] = safe_send(name)
-      elsif field.is_a?(GraphQL::Syntax::Edge)
-        edge = safe_send(field.identifier)
-        edge.calls = field.call_hash
-        edge.fields = field.fields
-        json[name] = edge.to_json
+    syntax_fields.each do |syntax_field|
+      key_name = syntax_field.alias_name || syntax_field.identifier
+      if key_name == 'node'
+        clone_node = self.class.new(target, fields: syntax_field.fields, query: query)
+        json[key_name] = clone_node.as_result
+      elsif key_name == 'cursor'
+        json[key_name] = cursor
+      else
+        field = get_field(syntax_field)
+        json[key_name] = field.as_result
       end
     end
     json
   end
 
-
-  def self.call(argument)
-    raise NotImplementedError, "Implement #{name}#call(argument) to use this node as a call"
+  # The object passed to {Query#initialize} as `context`.
+  def context
+    query.context
   end
 
-  def self.field_reader(*field_names)
-    field_names.each do |field_name|
-      define_method(field_name) do
-        @target.public_send(field_name)
+
+  class << self
+    # Registers this node in {GraphQL::SCHEMA}
+    def inherited(child_class)
+      # use name to prevent autoloading Connection
+      if child_class.ancestors.map(&:name).include?("GraphQL::Connection")
+        GraphQL::SCHEMA.add_connection(child_class)
       end
     end
-  end
 
-  def self.edges(field_name, collection_class_name:, edge_class_name:)
-    define_method(field_name) do
-      collection_items = @target.send(field_name)
-      collection_class = Object.const_get(collection_class_name)
-      edge_class = Object.const_get(edge_class_name)
-      collection = collection_class.new(items: collection_items, edge_class: edge_class)
+    # @param [String] class_name name of the class this node will wrap.
+    def exposes(ruby_class_name)
+      @ruby_class_name = ruby_class_name
+      GraphQL::SCHEMA.add_type(self)
+    end
+
+    # The name of the class wrapped by this node
+    def ruby_class_name
+      @ruby_class_name
+    end
+
+    # @param [String] describe
+    # Provide a description for this node which will be accessible from {SCHEMA}
+    def desc(describe)
+      @description = describe
+    end
+
+    # The description of this node
+    def description
+      @description || raise("#{name}.description isn't defined")
+    end
+
+    # @param [String] type_name
+    # Declares an alternative name to use in {GraphQL::SCHEMA}
+    def type(type_name)
+      @type_name = type_name.to_s
+      GraphQL::SCHEMA.add_type(self)
+    end
+
+    # Returns the name of this node used by {GraphQL::SCHEMA}
+    def schema_name
+      @type_name || default_schema_name
+    end
+
+    def default_schema_name
+      name.split("::").last.sub(/Node$/, '').underscore
+    end
+
+    # @param [String] field_name name of the field to be used as the cursor
+    # Declares what field will be used as the cursor for this node.
+    def cursor(field_name)
+      define_method "cursor" do
+        field_class = self.class.all_fields[field_name.to_s]
+        field = field_class.new(query: query, owner: self, calls: [])
+        cursor = GraphQL::Types::CursorField.new(field.as_result)
+        cursor.as_result
+      end
+    end
+
+    # All accessible fields on this node (including those defined in parent classes)
+    def all_fields
+      superclass.all_fields.merge(own_fields)
+    rescue NoMethodError
+      own_fields
+    end
+
+    # Fields defined by this class, but not its parents
+    def own_fields
+      @own_fields ||= {}
+    end
+
+    # @return [GraphQL::FieldDefiner] definer
+    def field
+      @field_definer ||= GraphQL::FieldDefiner.new(self)
+    end
+
+    # @param [String] field_name
+    # Un-define field with name `field_name`
+    def remove_field(field_name)
+      own_fields.delete(field_name.to_s)
     end
   end
 
+  private
 
-  def self.cursor(field_name)
-    define_method "cursor" do
-      safe_send(field_name).to_s
+  def get_field(syntax_field)
+    field_class = self.class.all_fields[syntax_field.identifier]
+    if syntax_field.identifier == "cursor"
+      cursor
+    elsif field_class.nil?
+      raise GraphQL::FieldNotDefinedError.new(self.class.name, syntax_field.identifier)
+    else
+      field_class.new(
+        query: query,
+        owner: self,
+        calls: syntax_field.calls,
+        fields: syntax_field.fields,
+      )
     end
   end
 end

data/lib/graphql/parser.rb

@@ -1,18 +1,29 @@
 class GraphQL::Parser < Parslet::Parser
-  root(:node)
-
+  root(:query)
+  rule(:query) { node.repeat.as(:nodes) >> variable.repeat.as(:variables) }
+  # node
   rule(:node) { space? >> call >> space? >> fields.as(:fields) }
 
-  rule(:fields) { str("{") >> space? >> ((edge | field) >> str(",").maybe >> space?).repeat(1) >> space? >> str("}") >> space?}
-
-  rule(:edge) { call_chain >> space? >> fields.as(:fields) }
-  rule(:call_chain) { identifier >> (dot >> call).repeat(0).as(:calls) }
+  # field set
+  rule(:fields) { str("{") >> space? >> (field >> separator?).repeat(1) >> space? >> str("}") >> space?}
 
-  rule(:call) { identifier >> str("(") >> name.maybe.as(:argument) >> str(")") }
+  #call
+  rule(:call) { identifier >> str("(") >> (argument.as(:argument) >> separator?).repeat(0).as(:arguments) >> str(")") }
   rule(:dot) { str(".") }
+  rule(:argument) { (identifier | variable_identifier)}
+
+  # field
+  rule(:field) { identifier >> call_chain.maybe >> alias_name.maybe >> space? >> fields.as(:fields).maybe }
+  rule(:call_chain) { (dot >> call).repeat(0).as(:calls) }
+  rule(:alias_name) { space >> str("as") >> space >> name.as(:alias_name) }
 
-  rule(:field) { identifier }
+  # variable
+  rule(:variable) { space? >> variable_identifier >> str(":") >> space? >> (name | json_string ).as(:json_string) >> space?}
+  rule(:json_string) { str("{") >> (match('[^{}]') | json_string).repeat >> str("}")}
+  rule(:variable_identifier) { (str("<") >> name >> str(">")).as(:identifier) }
 
+  # general purpose
+  rule(:separator?) { str(",").maybe >> space? }
   rule(:identifier) { name.as(:identifier) }
   rule(:name) { match('\w').repeat(1) }
   rule(:space) { match('[\s\n]+').repeat(1) }

data/lib/graphql/query.rb

@@ -1,41 +1,84 @@
+# Executes queries from strings against {GraphQL::SCHEMA}.
+#
+# @example
+#   query_str = "post(1) { title, comments { count } }"
+#   query_ctx = {user: current_user}
+#   query = GraphQL::Query.new(query_str, context: query_ctx)
+#   result = query.as_result
+
 class GraphQL::Query
-  attr_reader :query_string, :root, :namespace
-  def initialize(query_string, namespace: Object)
+  attr_reader :query_string, :root, :context
+
+  # @param [String] query_string the string to be parsed
+  # @param [Object] context an object which will be available to all nodes and fields in the schema
+  def initialize(query_string, context: nil)
     if !query_string.is_a?(String) || query_string.length == 0
       raise "You must send a query string, not a #{query_string.class.name}"
     end
     @query_string = query_string
     @root = parse(query_string)
-    @namespace = namespace
-  end
-
-  def to_json
-    root_node = make_call(nil, root.identifier, root.argument)
-    raise "Couldn't find root for #{root.identifier}(#{root.argument})" if root.nil?
-
-    root_node.fields = root.fields
-    {
-      root_node.cursor => root_node.to_json
-    }
+    @context = context
   end
 
-  def get_node(identifier)
-    name = "#{identifier}_node"
-    namespace.const_get(name.camelize)
+  # @return [Hash] result the JSON response to this query
+  # Calling {#as_result} more than once won't cause the query to be re-run
+  def as_result
+    @as_result ||= execute!
   end
 
-  def make_call(context, name, *arguments)
-    if context.nil?
-      context = get_node(name)
-      name = "call"
+  # @param [String] identifier
+  # returns a query variable named `identifier`, otherwise raises.
+  def get_variable(identifier)
+    syntax_var = @root.variables.find { |v| v.identifier == identifier }
+    if syntax_var.blank?
+      raise "No variable found for #{identifier}, defined variables are #{@root.variables.map(&:identifier)}"
     end
-    context.send(name, *arguments)
+    syntax_var
   end
 
   private
 
+  def execute!
+    root_syntax_node = root.nodes[0]
+    root_call_identifier = root_syntax_node.identifier
+    root_call_class = GraphQL::SCHEMA.get_call(root_call_identifier)
+    root_call = root_call_class.new(query: self, syntax_arguments: root_syntax_node.arguments)
+    result_object = root_call.as_result
+    return_declarations = root_call_class.return_declarations
+    result = {}
+
+    if result_object.is_a?(Hash)
+      result_object.each do |name, value|
+        node_class = GraphQL::SCHEMA.type_for_object(value)
+        field_for_node = root_syntax_node.fields.find {|f| f.identifier == name.to_s }
+        if field_for_node.present?
+          fields_for_node = field_for_node.fields
+          node_value = node_class.new(value,query: self, fields: fields_for_node)
+          result[name.to_s] = node_value.as_result
+        end
+      end
+    elsif result_object.is_a?(Array)
+      fields_for_node = root_syntax_node.fields
+      result_object.each do |item|
+        node_class = GraphQL::SCHEMA.type_for_object(item)
+        node_value = node_class.new(item, query: self, fields: fields_for_node)
+        result[node_value.cursor] = node_value.as_result
+      end
+    else
+      node_class = GraphQL::SCHEMA.type_for_object(result_object)
+      fields_for_node = root_syntax_node.fields
+      node_value = node_class.new(result_object, query: self, fields: fields_for_node)
+      result[node_value.cursor] = node_value.as_result
+    end
+
+    result
+  end
+
   def parse(query_string)
     parsed_hash = GraphQL::PARSER.parse(query_string)
     root_node = GraphQL::TRANSFORM.apply(parsed_hash)
+  rescue Parslet::ParseFailed => error
+    line, col = error.cause.source.line_and_column
+    raise GraphQL::SyntaxError.new(line, col, query_string)
   end
 end

data/lib/graphql/root_call.rb

@@ -0,0 +1,176 @@
+# Every query begins with a root call. It might find data or mutate data and return some results.
+#
+# A root call should:
+#
+# - declare any arguments with {.argument}, or declare `argument.none`
+# - declare returns with {.return}
+# - implement {#execute!} to take those arguments and return values
+#
+# @example
+#   FindPostCall < GraphQL::RootCall
+#     argument.number(:ids, any_number: true)
+#     returns :post
+#
+#     def execute!(*ids)
+#       ids.map { |id| Post.find(id) }
+#     end
+#   end
+#
+# @example
+#   CreateCommentCall < GraphQL::RootCall
+#     argument.number(:post_id)
+#     argument.object(:comment)
+#     returns :post, :comment
+#
+#     def execute!(post_id, comment)
+#       post = Post.find(post_id)
+#       new_comment = post.comments.create!(comment)
+#       {
+#         comment: new_comment,
+#         post: post,
+#       }
+#     end
+#   end
+#
+class GraphQL::RootCall
+  attr_reader :query, :arguments
+  def initialize(query:, syntax_arguments:)
+    @query = query
+
+    raise "#{self.class.name} must declare arguments" unless self.class.arguments
+    @arguments = syntax_arguments.each_with_index.map do |syntax_arg, idx|
+
+      value = if syntax_arg[0] == "<"
+          query.get_variable(syntax_arg).json_string
+        else
+          syntax_arg
+        end
+
+      self.class.typecast(idx, value)
+    end
+  end
+
+  def execute!(*args)
+    raise NotImplementedError, "Do work in this method"
+  end
+
+  def context
+    query.context
+  end
+
+  def as_result
+    return_declarations = self.class.return_declarations
+    raise "#{self.class.name} must declare returns" unless return_declarations.present?
+    return_values = execute!(*arguments)
+
+    if return_values.is_a?(Hash)
+      unexpected_returns = return_values.keys - return_declarations.keys
+      missing_returns = return_declarations.keys - return_values.keys
+      if unexpected_returns.any?
+        raise "#{self.class.name} returned #{unexpected_returns}, but didn't declare them."
+      elsif missing_returns.any?
+        raise "#{self.class.name} declared #{missing_returns}, but didn't return them."
+      end
+    end
+    return_values
+  end
+
+  class << self
+    # @param [String] ident_name
+    # Declare an alternative name used in a query string
+    def indentifier(ident_name)
+      @identifier = ident_name
+      GraphQL::SCHEMA.add_call(self)
+    end
+
+    # The name used by {GraphQL::SCHEMA}. Uses {.identifier} or derives a name from the class name.
+    def schema_name
+      @identifier || name.split("::").last.sub(/Call$/, '').underscore
+    end
+
+    def inherited(child_class)
+      GraphQL::SCHEMA.add_call(child_class)
+    end
+
+    # This call won't be visible in `schema()`
+    def abstract!
+      GraphQL::SCHEMA.remove_call(self)
+    end
+
+    # @param [Symbol] return_declarations
+    # Name of returned values from this call
+    def returns(*return_declaration_names)
+      if return_declaration_names.last.is_a?(Hash)
+        return_declarations_hash = return_declaration_names.pop
+      else
+        return_declarations_hash = {}
+      end
+
+      raise "Return keys must be symbols" if  (return_declarations.keys + return_declaration_names).any? { |k| !k.is_a?(Symbol) }
+
+      return_declaration_names.each do |return_sym|
+        return_type = return_sym.to_s
+        return_declarations[return_sym] = return_type
+      end
+
+      return_declarations_hash.each do |return_sym, return_type|
+        return_declarations[return_sym] = return_type
+      end
+    end
+
+    def return_declarations
+      @return_declarations ||= {}
+    end
+
+    # @return [GraphQL::RootCallArgumentDefiner] definer
+    # Use this object to declare arguments.
+    def argument
+      @argument ||= GraphQL::RootCallArgumentDefiner.new(self)
+    end
+
+    def own_arguments
+      @argument && @argument.arguments
+    end
+
+    def arguments
+      own = own_arguments || []
+      own + superclass.arguments
+    rescue NoMethodError
+      own
+    end
+
+    def argument_for_index(idx)
+      if arguments.first.any_number
+        arguments.first
+      else
+        arguments[idx]
+      end
+    end
+
+    TYPE_CHECKS = {
+      "object" => Hash,
+      "number" => Numeric,
+      "string" => String,
+    }
+
+    def typecast(idx, value)
+      arg_dec = argument_for_index(idx)
+      expected_type = arg_dec.type
+      expected_type_class = TYPE_CHECKS[expected_type]
+
+      if expected_type == "string"
+        parsed_value = value
+      else
+        parsed_value = JSON.parse('{ "value" : ' + value + '}')["value"]
+      end
+
+      if !parsed_value.is_a?(expected_type_class)
+        raise GraphQL::RootCallArgumentError.new(arg_dec, value)
+      end
+
+      parsed_value
+    rescue JSON::ParserError
+      raise GraphQL::RootCallArgumentError.new(arg_dec, value)
+    end
+  end
+end