graphql 0.0.1 → 0.0.2

data/lib/graphql/root_call_argument.rb

@@ -0,0 +1,8 @@
+class GraphQL::RootCallArgument
+  attr_reader :type, :name, :any_number
+  def initialize(type:, name:, any_number: false)
+    @type = type
+    @name = name
+    @any_number = any_number
+  end
+end

data/lib/graphql/root_call_argument_definer.rb

@@ -0,0 +1,20 @@
+class GraphQL::RootCallArgumentDefiner
+  ARGUMENT_TYPES = [:string, :object, :number]
+
+  attr_reader :arguments
+
+  def initialize(call_class)
+    @call_class = call_class
+    @arguments = []
+  end
+
+  def none
+    @arguments = []
+  end
+
+  ARGUMENT_TYPES.each do |arg_type|
+    define_method arg_type do |name, any_number: false|
+      @arguments << GraphQL::RootCallArgument.new(type: arg_type.to_s, name: name.to_s, any_number: any_number)
+    end
+  end
+end

data/lib/graphql/schema.rb

@@ -0,0 +1,99 @@
+# {GraphQL::SCHEMA} keeps track of defined nodes, fields and calls.
+# Although you don't interact with it directly, it responds to queries for `schema()` and `__type__` info.
+
+class GraphQL::Schema
+  include Singleton
+  attr_reader :types, :calls, :fields, :class_names, :connections
+  def initialize
+    @types = {}
+    @connections = {}
+    @fields = {}
+    @class_names = {}
+    @calls = {}
+  end
+
+  def add_call(call_class)
+    remove_call(call_class)
+    @calls[call_class.schema_name] = call_class
+  end
+
+  def get_call(identifier)
+    @calls[identifier.to_s] || raise(GraphQL::RootCallNotDefinedError.new(identifier))
+  end
+
+  def remove_call(call_class)
+    existing_name = @calls.key(call_class)
+    if existing_name
+      @calls.delete(existing_name)
+    end
+  end
+
+  def call_names
+    @calls.keys
+  end
+
+  def add_type(node_class)
+    existing_name = @types.key(node_class)
+    if existing_name
+      @types.delete(existing_name)
+    end
+
+    @class_names[node_class.ruby_class_name] = node_class
+    @types[node_class.schema_name] = node_class
+  end
+
+  def get_type(identifier)
+    @types[identifier.to_s] || raise(GraphQL::NodeNotDefinedError.new(identifier))
+  end
+
+  def type_names
+    @types.keys
+  end
+
+  def type_for_object(app_object)
+    registered_class_names = @class_names.keys
+    if app_object.is_a?(Class)
+      app_class = app_object
+    else
+      app_class = app_object.class
+    end
+    app_class.ancestors.map(&:name).each do |class_name|
+      if registered_class_names.include?(class_name)
+        return @class_names[class_name]
+      end
+    end
+    raise "Couldn't find node for class #{app_class} #{app_object} (ancestors: #{app_class.ancestors.map(&:name)}, defined: #{registered_class_names})"
+  end
+
+  def add_connection(node_class)
+    existing_name = @connections.key(node_class)
+    if existing_name
+      @connections.delete(existing_name)
+    end
+    @connections[node_class.schema_name.to_s] = node_class
+  end
+
+  def get_connection(identifier)
+    @connections[identifier] || GraphQL::Connection.default_connection || raise(GraphQL::ConnectionNotDefinedError.new(identifier))
+  end
+
+  def connection_names
+    @connections.keys
+  end
+
+  def add_field(field_class)
+    existing_name = @fields.key(field_class)
+    if existing_name
+      @fields.delete(existing_name)
+    end
+    @fields[field_class.schema_name.to_s] = field_class
+  end
+
+  def get_field(identifier)
+    @fields[identifier.to_s] || raise(GraphQL::FieldNotDefinedError.new("<unknown>", identifier))
+  end
+
+  def field_names
+    @fields.keys
+  end
+end

data/lib/graphql/syntax/call.rb

@@ -1,17 +1,8 @@
 class GraphQL::Syntax::Call
-  attr_reader :identifier, :argument, :calls
-  def initialize(identifier:, argument: nil, calls: [])
+  attr_reader :identifier, :arguments, :calls
+  def initialize(identifier:, arguments: nil, calls: [])
     @identifier = identifier
-    @argument = argument
+    @arguments = arguments
     @calls = calls
   end
-
-  def execute!(query)
-    node_class = query.get_node(identifier)
-    node_class.call(argument)
-  end
-
-  def to_query
-    (["#{identifier}(#{argument})"] + calls.map(&:to_query)).join(".")
-  end
 end

data/lib/graphql/syntax/field.rb

@@ -1,7 +1,9 @@
 class GraphQL::Syntax::Field
-  attr_reader :identifier, :calls
-  def initialize(identifier:, calls: [])
+  attr_reader :identifier, :alias_name, :calls, :fields
+  def initialize(identifier:, alias_name: nil, calls: [], fields: [])
     @identifier = identifier
+    @alias_name = alias_name
     @calls = calls
+    @fields = fields
   end
 end

data/lib/graphql/syntax/node.rb

@@ -1,15 +1,8 @@
 class GraphQL::Syntax::Node
-  attr_reader :identifier, :argument, :fields
-  def initialize(identifier:, argument:, fields: [])
+  attr_reader :identifier, :arguments, :fields
+  def initialize(identifier:, arguments:, fields: [])
     @identifier = identifier
-    @argument = argument
+    @arguments = arguments
     @fields = fields
   end
-
-  def execute!(query)
-    obj = identifier.execute!(query)
-    fields.each do |field|
-      obj.apply_field(field)
-    end
-  end
 end

data/lib/graphql/syntax/query.rb

@@ -0,0 +1,7 @@
+class GraphQL::Syntax::Query
+  attr_reader :nodes, :variables
+  def initialize(nodes:, variables:)
+    @nodes = nodes
+    @variables = variables
+  end
+end

data/lib/graphql/syntax/variable.rb

@@ -0,0 +1,7 @@
+class GraphQL::Syntax::Variable
+  attr_reader :identifier, :json_string
+  def initialize(identifier:, json_string:)
+    @identifier = identifier
+    @json_string = json_string
+  end
+end

data/lib/graphql/transform.rb

@@ -1,10 +1,19 @@
 class GraphQL::Transform < Parslet::Transform
+  # query
+  rule(nodes: sequence(:n), variables: sequence(:v)) { GraphQL::Syntax::Query.new(nodes: n, variables: v)}
   # node
-  rule(identifier: simple(:i), argument: simple(:a), fields: sequence(:f)) {GraphQL::Syntax::Node.new(identifier: i.to_s, argument: a, fields: f)}
-  # edge
-  rule(identifier: simple(:i), calls: sequence(:c), fields: sequence(:f)) { GraphQL::Syntax::Edge.new(identifier: i.to_s, fields: f, calls: c)}
+  rule(identifier: simple(:i), arguments: sequence(:a), fields: sequence(:f)) {GraphQL::Syntax::Node.new(identifier: i.to_s, arguments: a, fields: f)}
   # field
-  rule(identifier: simple(:i)) { GraphQL::Syntax::Field.new(identifier: i.to_s)}
+  rule(identifier: simple(:i), calls: sequence(:c), fields: sequence(:f), alias_name: simple(:a)) { GraphQL::Syntax::Field.new(identifier: i.to_s, fields: f, calls: c, alias_name: a.to_s)}
+  rule(identifier: simple(:i), calls: sequence(:c), alias_name: simple(:a)) { GraphQL::Syntax::Field.new(identifier: i.to_s, calls: c, alias_name: a.to_s)}
+  rule(identifier: simple(:i), calls: sequence(:c), fields: sequence(:f)) { GraphQL::Syntax::Field.new(identifier: i.to_s, fields: f, calls: c)}
+  rule(identifier: simple(:i), calls: sequence(:c)) { GraphQL::Syntax::Field.new(identifier: i.to_s, calls: c)}
+  rule(identifier: simple(:i), alias_name: simple(:a)) { GraphQL::Syntax::Field.new(identifier: i.to_s, alias_name: a.to_s)}
   # call
-  rule(identifier: simple(:i), argument: simple(:a)) { GraphQL::Syntax::Call.new(identifier: i.to_s, argument: a) }
+  rule(identifier: simple(:i), arguments: sequence(:a)) { GraphQL::Syntax::Call.new(identifier: i.to_s, arguments: a) }
+  # argument
+  rule(argument: simple(:a)) { a.to_s }
+  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)}
 end

data/lib/graphql/types/boolean_field.rb

@@ -0,0 +1,3 @@
+class GraphQL::Types::BooleanField < GraphQL::Field
+  type :boolean
+end

data/lib/graphql/types/connection_field.rb

@@ -0,0 +1,30 @@
+class GraphQL::Types::ConnectionField < GraphQL::Field
+  type "connection"
+
+  ["connection_class_name", "node_class_name"].each do |method_name|
+    define_method(method_name) do
+      const_get(method_name.upcase)
+    end
+  end
+
+  def connection_class
+    if connection_class_name.present?
+      Object.const_get(connection_class_name)
+    else
+      GraphQL::SCHEMA.get_connection(name)
+    end
+  end
+
+  def as_node
+    items = finished_value
+    connection_class.new(
+      items,
+      query: query,
+      fields: fields,
+    )
+  end
+
+  def as_result
+    as_node.as_result
+  end
+end

data/lib/graphql/types/cursor_field.rb

@@ -0,0 +1,9 @@
+class GraphQL::Types::CursorField
+  def initialize(value)
+    @value = value
+  end
+
+  def as_result
+    @value.to_s
+  end
+end

data/lib/graphql/types/number_field.rb

@@ -0,0 +1,3 @@
+class GraphQL::Types::NumberField < GraphQL::Field
+  type "number"
+end

data/lib/graphql/types/object_field.rb

@@ -0,0 +1,8 @@
+class GraphQL::Types::ObjectField < GraphQL::Field
+  type "object"
+  def as_result
+    node_class = GraphQL::SCHEMA.type_for_object(finished_value)
+    node = node_class.new(finished_value, query: query, fields: fields)
+    node.as_result
+  end
+end

data/lib/graphql/types/string_field.rb

@@ -0,0 +1,3 @@
+class GraphQL::Types::StringField < GraphQL::Field
+  type :string
+end

data/lib/graphql/types/type_field.rb

@@ -0,0 +1,6 @@
+class GraphQL::Types::TypeField < GraphQL::Types::ObjectField
+  type "__type__"
+  def finished_value
+    GraphQL::SCHEMA.get_type(self.owner.class.schema_name)
+  end
+end

data/lib/graphql/version.rb

@@ -0,0 +1,3 @@
+module GraphQL
+  VERSION = "0.0.2"
+end

data/readme.md

@@ -1,18 +1,150 @@
 # graphql
 
-- Parser & tranform from [parslet](http://kschiess.github.io/parslet/)
-- Your app can implement nodes
-- You can pass strings to `GraphQL::Query` and execute them with your nodes
+[![Build Status](https://travis-ci.org/rmosolgo/graphql-ruby.svg?branch=master)](https://travis-ci.org/rmosolgo/graphql-ruby)
+[![Gem Version](https://badge.fury.io/rb/graphql.svg)](https://rubygems.org/gems/graphql)
+[![Dependency Status](https://gemnasium.com/rmosolgo/graphql-ruby.svg)](https://gemnasium.com/rmosolgo/graphql-ruby)
 
-See `/spec/support/dummy_app/nodes.rb` for node examples
 
-__Nodes__ provide information to queries by mapping to application objects (via `.call` and `field_reader`) or implementing fields themselves (eg `Nodes::PostNode#teaser`).
+Create a GraphQL interface by implementing _nodes_ and _connections_, then running queries.
 
-__Edges__ handle node-to-node relationships.
+## To do:
 
 
-## To do:
+- Allow a default connection class, or some way to infer connection from name
+  - right now, `Introspection::Connection` isn't getting used, only `ApplicationConnection` is.
+
+- How do you express failure? HTTP response? `errors` key?
+- Handle blank objects in nested calls
+- Implement calls as arguments
+- double-check how to handle `pals.first(3) { count }`
+- Implement call argument introspection (wait for spec)
+- For fields that return objects, can they be queried _without_ other fields? Or must they always have fields?
+- __document__ (wait for spec)
+
+## Example Implementation
+
+- See test implementation in [`/spec/support/dummy_app/nodes.rb`](https://github.com/rmosolgo/graphql/blob/master/spec/support/nodes.rb)
+- See `graphql-ruby-demo` with Rails on [github](https://github.com/rmosolgo/graphql-ruby-demo) or [heroku](http://graphql-ruby-demo.herokuapp.com/)
+
+![gql](https://cloud.githubusercontent.com/assets/2231765/6217972/5d24edda-b5ce-11e4-9e07-3548304af862.png)
+
+
+## Usage
+
+- Implement _nodes_ that wrap objects in your application
+- Implement _calls_ that return those objects (and may mutate the application state)
+- Execute _queries_ and return the result.
+
+### Nodes
+
+Nodes are delegators that wrap objects in your app. You must whitelist fields by declaring them in the class definition.
+
+
+```ruby
+class FishNode < GraphQL::Node
+  exposes "Fish"
+  cursor(:id)
+  field.number(:id)
+  field.string(:name)
+  field.string(:species)
+  field.object(:aquarium)
+end
+```
+
+You can also declare connections between objects:
+
+```ruby
+class AquariumNode < GraphQL::Node
+  exposes "Aquarium"
+  cursor(:id)
+  field.number(:id)
+  field.number(:occupancy)
+  field.connection(:fishes)
+end
+```
+
+### Calls
+
+Calls selectively expose your application to the world. They always return values and they may perform mutations.
+
+Calls declare returns, declare arguments, and implement `#execute!`.
+
+This call just finds values:
+
+```ruby
+class FindFishCall < GraphQL::RootCall
+  returns :fish
+  argument.number(:id)
+  def execute!(id)
+    Fish.find(id)
+  end
+end
+```
+
+This call performs a mutation:
+
+```ruby
+class RelocateFishCall < GraphQL::RootCall
+  returns :fish, :previous_aquarium, :new_aquarium
+  argument.number(:fish_id)
+  argument.number(:new_aquarium_id)
+
+  def execute!(fish_id, new_aquarium_id)
+    fish = Fish.find(fish_id)
+
+    # context is defined by the query, see below
+    if !context[:user].can_move?(fish)
+      raise RelocateNotAllowedError
+    end
+
+    previous_aquarium = fish.aquarium
+    new_aquarium = Aquarium.find(new_aquarium_id)
+    fish.update_attributes(aquarium: new_aquarium)
+    {
+      fish: fish,
+      previous_aquarium: previous_aquarium,
+      new_aquarium: new_aquarium,
+    }
+  end
+end
+```
+
+### Queries
+
+When your system is setup, you can perform queries from a string.
+
+```ruby
+query_str = "find_fish(1) { name, species } "
+query     = GraphQL::Query.new(query_str)
+result    = query.as_result
+
+result
+# {
+#   "1" => {
+#     "name" => "Sharky",
+#     "species" => "Goldfish",
+#   }
+# }
+```
+
+Each query may also define a `context` object which will be accessible at every point in execution.
+
+```ruby
+query_str = "move_fish(1, 3) { fish { name }, new_aquarium { occupancy } }"
+query_ctx = {user: current_user, request: request}
+query     = GraphQL::Query.new(query_str, context: query_ctx)
+result    = query.as_result
+
+result
+# {
+#   "fish" => {
+#     "name" => "Sharky"
+#   },
+#   "new_aquarium" => {
+#     "occupancy" => 12
+#   }
+# }
+```
+
+You could do something like this [inside a Rails controller](https://github.com/rmosolgo/graphql-ruby-demo/blob/master/app/controllers/queries_controller.rb#L5).
 
-- Better class inference. Declaring edge classes is stupid.
-- How to authenticate?
-- What do graphql mutation queries even look like?