graphql 0.0.3 → 0.0.4

data/lib/graphql/introspection/{call_node.rb → call_type.rb}

@@ -1,4 +1,4 @@
-class GraphQL::Introspection::CallNode < GraphQL::Node
+class GraphQL::Introspection::CallType < GraphQL::Node
   exposes "GraphQL::Call"
   field.string(:name)
   field.string(:arguments)

data/lib/graphql/introspection/field_type.rb

@@ -0,0 +1,10 @@
+class GraphQL::Introspection::FieldType < GraphQL::Node
+  exposes "GraphQL::Field"
+  field.string(:name)
+  field.string(:type)
+  field.introspection_connection(:calls)
+
+  def calls
+    target.type_class.calls.values
+  end
+end

data/lib/graphql/introspection/{root_call_node.rb → root_call_type.rb}

@@ -1,8 +1,8 @@
-class GraphQL::Introspection::RootCallNode < GraphQL::Node
+class GraphQL::Introspection::RootCallType < GraphQL::Node
   exposes "GraphQL::RootCall"
   field.string(:name)
   field.string(:returns)
-  field.connection(:arguments)
+  field.introspection_connection(:arguments)
 
 
   def returns
@@ -13,4 +13,8 @@ class GraphQL::Introspection::RootCallNode < GraphQL::Node
   def name
     schema_name
   end
+
+  def arguments
+    target.arguments.values
+  end
 end

data/lib/graphql/introspection/schema_type.rb

@@ -0,0 +1,17 @@
+class GraphQL::Introspection::SchemaType < GraphQL::Node
+  exposes "GraphQL::Schema::Schema"
+  field.introspection_connection(:calls)
+  field.introspection_connection(:types)
+
+  def cursor
+    "schema"
+  end
+
+  def types
+    @target.types.values
+  end
+
+  def calls
+    target.calls.values
+  end
+end

data/lib/graphql/introspection/{type_node.rb → type_type.rb}

@@ -1,11 +1,13 @@
-class GraphQL::Introspection::TypeNode < GraphQL::Node
+class GraphQL::Introspection::TypeType < GraphQL::Node
   exposes "GraphQL::Node"
+  type "__type__"
   field.string(:name)
   field.string(:description)
-  field.connection(:fields)
+  field.introspection_connection(:fields)
 
   cursor :name
 
+  # they're actually {FieldMapping}s
   def fields
     target.all_fields.values
   end

data/lib/graphql/node.rb

@@ -5,8 +5,9 @@
 # - Extend `GraphQL::Node`
 # - Declare what this node will wrap with {.exposes}
 # - Declare fields with {.field}
+# - Declare calls with {.call}
 #
-# @example
+# @example Expose a class in your app
 #   class PostNode < GraphQL::Node
 #     exposes('Post')
 #
@@ -18,19 +19,35 @@
 #     field.connection(:comments)
 #   end
 #
-
+# @example Expose a data type
+#   class DateType < GraphQL::Node
+#     exposes "Date"
+#     type :date
+#     call :minus_days, -> (prev_value, minus_days) { prev_value - minus_days.to_i }
+#     field.number(:year)
+#     field.number(:month)
+#   end
+#
+#   # now you could use it
+#   class PostNode
+#     field.date(:published_at)
+#   end
 class GraphQL::Node
-  # The object wrapped by this `Node`
+  # The object wrapped by this `Node`, _before_ calls are applied
+  attr_reader :original_target
+  # The object wrapped by this `Node`, _after_ calls are applied
   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, fields:, query:)
-    @target = target
+  def initialize(target=nil, fields:, query:, calls: [])
     @query = query
+    @calls = calls
     @syntax_fields = fields
+    @original_target = target
+    @target = apply_calls(target)
   end
 
   # If the target responds to `method_name`, send it to target.
@@ -44,20 +61,29 @@ class GraphQL::Node
 
   # Looks up {#syntax_fields} against this node and returns the results
   def as_result
-    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
+    @as_result ||= begin
+      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, calls: syntax_field.calls)
+          json[key_name] = clone_node.as_result
+        elsif key_name == 'cursor'
+          json[key_name] = cursor
+        elsif key_name[0] == "$"
+          fragment = query.fragments[key_name]
+          # execute the fragment and merge it into this result
+          clone_node = self.class.new(target, fields: fragment.fields, query: query, calls: @calls)
+          json.merge!(clone_node.as_result)
+        else
+          field = get_field(syntax_field)
+          new_target = public_send(field.name)
+          new_node = field.type_class.new(new_target, fields: syntax_field.fields, query: query, calls: syntax_field.calls)
+          json[key_name] = new_node.as_result
+        end
       end
+      json
     end
-    json
   end
 
   # The object passed to {Query#initialize} as `context`.
@@ -65,25 +91,38 @@ class GraphQL::Node
     query.context
   end
 
+  def __type__
+    self.class
+  end
 
-  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)
+  def apply_calls(value)
+    finished_value(value)
+  end
+
+  def finished_value(raw_value)
+    @finished_value ||= begin
+      val = raw_value
+      @calls.each do |call|
+        registered_call = self.class.calls[call.identifier]
+        if registered_call.nil?
+          raise "Call not found: #{self.class.name}##{call.identifier}"
+        end
+        val = registered_call.lambda.call(val, *call.arguments)
       end
+      val
     end
+  end
 
+  class << self
     # @param [String] class_name name of the class this node will wrap.
-    def exposes(ruby_class_name)
-      @ruby_class_name = ruby_class_name
+    def exposes(*exposes_class_names)
+      @exposes_class_names = exposes_class_names
       GraphQL::SCHEMA.add_type(self)
     end
 
-    # The name of the class wrapped by this node
-    def ruby_class_name
-      @ruby_class_name
+    # The names of the classes wrapped by this node
+    def exposes_class_names
+      @exposes_class_names || []
     end
 
     # @param [String] describe
@@ -110,17 +149,15 @@ class GraphQL::Node
     end
 
     def default_schema_name
-      name.split("::").last.sub(/Node$/, '').underscore
+      name.split("::").last.sub(/(Node|Type)$/, '').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
+        field_mapping = self.class.all_fields[field_name.to_s]
+        public_send(field_mapping.name).to_s
       end
     end
 
@@ -146,23 +183,62 @@ class GraphQL::Node
     def remove_field(field_name)
       own_fields.delete(field_name.to_s)
     end
+
+    # Can the node handle a field with this name?
+    def respond_to_field?(field_name)
+      if all_fields[field_name.to_s].blank?
+        false
+      elsif method_defined?(field_name)
+        true
+      elsif exposes_class_names.any? do |exposes_class_name|
+          exposes_class = Object.const_get(exposes_class_name)
+          exposes_class.method_defined?(field_name) || exposes_class.respond_to?(field_name)
+        end
+        true
+      else
+        false
+      end
+    end
+
+    def calls
+      superclass.calls.merge(own_calls)
+    rescue NoMethodError
+      {}
+    end
+    # @param [String] name the identifier for this call
+    # @param [lambda] operation the transformation this call makes
+    #
+    # Define a call that can be made on nodes of this type.
+    # The `lambda` receives arguments:
+    # - 1: `previous_value` -- the value of this node
+    # - *: arguments passed in the query (as strings)
+    #
+    # @example
+    #   # upcase a string field:
+    #   call :upcase, -> (prev_value) { prev_value.upcase }
+    # @example
+    #   # tests a number field:
+    #   call :greater_than, -> (prev_value, test_value) { prev_value > test_value.to_f }
+    #   # (`test_value` is passed in as a string)
+    def call(name, lambda)
+      own_calls[name.to_s] = GraphQL::Call.new(name: name.to_s, lambda: lambda)
+    end
+
+    def own_calls
+      @own_calls ||= {}
+    end
   end
 
   private
 
   def get_field(syntax_field)
-    field_class = self.class.all_fields[syntax_field.identifier]
+    field_mapping = 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)
+    elsif field_mapping.nil?
+      raise GraphQL::FieldNotDefinedError.new(self.class, syntax_field.identifier)
     else
-      field_class.new(
-        query: query,
-        owner: self,
-        calls: syntax_field.calls,
-        fields: syntax_field.fields,
-      )
+      field_mapping
     end
   end
 end

data/lib/graphql/{parser.rb → parser/parser.rb}

@@ -1,22 +1,27 @@
 # 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
+class GraphQL::Parser::Parser < Parslet::Parser
   root(:query)
-  rule(:query) { node.repeat.as(:nodes) >> variable.repeat.as(:variables) }
+  rule(:query) { node.repeat.as(:nodes) >> variable.repeat.as(:variables) >> fragment.repeat.as(:fragments) }
+
   # node
   rule(:node) { space? >> call >> space? >> fields.as(:fields) }
 
+  # fragment
+  rule(:fragment) { space? >> fragment_identifier >> str(":") >> space? >> fields.as(:fields) >> space?}
+  rule(:fragment_identifier) { (str("$") >> name).as(:identifier) }
+
   # field set
   rule(:fields) { str("{") >> space? >> (field >> separator?).repeat(1) >> space? >> str("}") >> space?}
 
-  #call
+  # 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(:field) { (identifier | fragment_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) }
 

data/lib/graphql/{transform.rb → parser/transform.rb}

@@ -1,7 +1,7 @@
 # {Transform} is a [parslet](http://kschiess.github.io/parslet/) transform for for turning the AST into objects in {GraphQL::Syntax}.
-class GraphQL::Transform < Parslet::Transform
+class GraphQL::Parser::Transform < Parslet::Transform
   # query
-  rule(nodes: sequence(:n), variables: sequence(:v)) { GraphQL::Syntax::Query.new(nodes: n, variables: v)}
+  rule(nodes: sequence(:n), variables: sequence(:v), fragments: sequence(:f)) { GraphQL::Syntax::Query.new(nodes: n, variables: v, fragments: f)}
   # node
   rule(identifier: simple(:i), arguments: sequence(:a), fields: sequence(:f)) {GraphQL::Syntax::Node.new(identifier: i.to_s, arguments: a, fields: f)}
   # field
@@ -17,4 +17,6 @@ class GraphQL::Transform < Parslet::Transform
   rule(identifier: simple(:i)) { i.to_s }
   # variable
   rule(identifier: simple(:i), json_string: simple(:j)) { GraphQL::Syntax::Variable.new(identifier: i.to_s, json_string: j.to_s)}
+  # fragment
+  rule(identifier: simple(:i), fields: sequence(:f)) { GraphQL::Syntax::Fragment.new(identifier: i, fields: f)}
 end

data/lib/graphql/query.rb

@@ -28,22 +28,25 @@ class GraphQL::Query
     @as_result ||= execute!
   end
 
-  # @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
-    syntax_var
+  # Provides access to query variables, raises an error if not found
+  # @example
+  #   query.variables["<person_data>"]
+  def variables
+    @variables ||= LookupHash.new("variable", @root.variables)
+  end
+
+  # Provides access to query fragments, raises an error if not found
+  # @example
+  #   query.fragments["$personData"]
+  def fragments
+    @fragments ||= LookupHash.new("fragment", @root.fragments)
   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_class = GraphQL::SCHEMA.get_call(root_syntax_node.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
@@ -83,4 +86,24 @@ class GraphQL::Query
     line, col = error.cause.source.line_and_column
     raise GraphQL::SyntaxError.new(line, col, query_string)
   end
+
+  # Caches items by name, raises an error if not found
+  class LookupHash
+    attr_reader :item_name, :items
+    def initialize(item_name, items)
+      @items = items
+      @item_name = item_name
+      @storage = Hash.new do |hash, identifier|
+        value = items.find {|i| i.identifier == identifier }
+        if value.blank?
+          "No #{item_name} found for #{identifier}, defined #{item_name}s are: #{items.map(&:identifier)}"
+        end
+        hash[identifier] = value
+      end
+    end
+
+    def [](identifier)
+      @storage[identifier]
+    end
+  end
 end

data/lib/graphql/root_call.rb

@@ -43,7 +43,7 @@ class GraphQL::RootCall
     @arguments = syntax_arguments.each_with_index.map do |syntax_arg, idx|
 
       value = if syntax_arg[0] == "<"
-          query.get_variable(syntax_arg).json_string
+          query.variables[syntax_arg].json_string
         else
           syntax_arg
         end
@@ -139,14 +139,34 @@ class GraphQL::RootCall
     end
 
     def own_arguments
-      @argument && @argument.arguments
+      @own_arguments ||= {}
     end
 
     def arguments
-      own = own_arguments || []
-      own + superclass.arguments
+      superclass.arguments.merge(own_arguments)
     rescue NoMethodError
-      own
+      {}
+    end
+
+    def add_argument(argument)
+      existing_argument = arguments[argument.name]
+      if existing_argument.blank?
+        # only assign an index if this variable wasn't already defined
+        argument.index = arguments.keys.length
+      else
+        # use the same index as the already-defined one
+        argument.index = existing_argument.index
+      end
+
+      own_arguments[argument.name] = argument
+    end
+
+    def argument_at_index(idx)
+      if arguments.values.first.any_number
+        arguments.values.first
+      else
+        arguments.values.find { |arg| arg.index == idx } || raise("No argument found for #{name} at index #{JSON.dump(idx)} (argument indexes: #{arguments.values.map(&:index)})")
+      end
     end
   end
 
@@ -158,16 +178,9 @@ class GraphQL::RootCall
     "string" => String,
   }
 
-  def argument_for_index(idx)
-    if self.class.arguments.first.any_number
-      self.class.arguments.first
-    else
-      self.class.arguments[idx]
-    end
-  end
 
   def typecast(idx, value)
-    arg_dec = argument_for_index(idx)
+    arg_dec = self.class.argument_at_index(idx)
     expected_type = arg_dec.type
     expected_type_class = TYPE_CHECKS[expected_type]