graphql-relay 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5fc4e49e9a152eb3d06a00ea6dc479ca20ad3b85
+  data.tar.gz: 3babba6d3a517b0d0a0da7afced0e005dcfa75f1
+SHA512:
+  metadata.gz: f84efd30fb1fe8cdd776656e5d8e3bba8ec2ff2cecdaf403fa2652dcc1d4bfced113b6535d89cdc51bf6f2033fc3702f284fc8c758f5329affaefedb4bb7dd3f
+  data.tar.gz: 9331b1c45d8401c462192fd5c431736dbd4924f812223781827dc145a4b7c2eb89e127431156ee8667e14aaae64f7d6466ec1cbc3f5e9a414f693efbbedde098

data/README.md

@@ -0,0 +1,73 @@
+# graphql-relay
+
+Helpers for using [`graphql`](https://github.com/rmosolgo/graphql-ruby) with Relay.
+
+## Installation
+
+```ruby
+gem "graphql-relay"
+```
+
+```
+bundle install
+```
+
+## Usage
+
+### Global Ids
+
+Global Ids provide refetching & global identification for Relay.
+
+You should implement an object that responds to `#object_from_id(global_id)` & `#type_from_object(object)`, then pass it to `GraphQL::Relay::Node.create(implementation)`. [Example](https://github.com/rmosolgo/graphql-relay-ruby/blob/120b750cf86f1eb5c9997b588f022b2ef3a0012c/spec/support/star_wars_schema.rb#L4-L15)
+
+Then, you can add global id fields to your types with `GraphQL::Relay::GlobalIdField.new(type_name)`. [Example](https://github.com/rmosolgo/graphql-relay-ruby/blob/120b750cf86f1eb5c9997b588f022b2ef3a0012c/spec/support/star_wars_schema.rb#L22)
+
+### Connections
+
+Connections will provide arguments, pagination and `pageInfo` for `Array`s or `ActiveRecord::Relation`s.
+
+To create a connection, you should:
+  - create a connection type; then
+  - implement the field to return objects
+
+To create a connection type, use either `GraphQL::Relay::ArrayConnection.create_type(base_type)` or for an `ActiveRecord::Relation`, use `GraphQL::Relay::RelationConnection.create_type(base_type)`. [Array example](https://github.com/rmosolgo/graphql-relay-ruby/blob/120b750cf86f1eb5c9997b588f022b2ef3a0012c/spec/support/star_wars_schema.rb#L27), [Relation example](https://github.com/rmosolgo/graphql-relay-ruby/blob/120b750cf86f1eb5c9997b588f022b2ef3a0012c/spec/support/star_wars_schema.rb#L39)
+
+Then, implement the field. It's different than a normal field:
+  - use the `connection` helper to define it, instead of `field`
+  - use the newly-created connection type as the field's return type
+  - implement `resolve` to return an Array or an ActiveRecord::Relation, depending on the connection type.
+
+[Example](https://github.com/rmosolgo/graphql-relay-ruby/blob/120b750cf86f1eb5c9997b588f022b2ef3a0012c/spec/support/star_wars_schema.rb#L48-L61)
+
+### Mutations
+
+Mutations allow Relay to mutate your system. When you define a mutation, you'll be defining:
+  - A field for your schema's `mutation` root
+  - A derived `InputObjectType` for input values
+  - A derived `ObjectType` for return values
+
+You _don't_ define anything having to do with `clientMutationId`. That's automatically created.
+
+To define a mutation, use `GraphQL::Relay::Mutation.define`. Inside the block, you should configure:
+  - `name`, which will name the mutation field & derived types
+  - `input_field`s, which will be applied to the derived `InputObjectType`
+  - `return_field`s, which will be applied to the derived `ObjectType`
+  - `resolve(-> (inputs, ctx))`, the mutation which will actually happen
+
+The resolve proc:
+  - Takes `inputs`, which is a hash whose keys are the ones defined by `input_field`
+  - Takes `ctx`, which is the query context you passed with the `context:` keyword
+  - Must return a hash with keys matching your defined `return_field`s
+
+Examples:
+  - Definition: [example](https://github.com/rmosolgo/graphql-relay-ruby/blob/120b750cf86f1eb5c9997b588f022b2ef3a0012c/spec/support/star_wars_schema.rb#L74-L93)
+  - Mount on mutation type: [example](https://github.com/rmosolgo/graphql-relay-ruby/blob/120b750cf86f1eb5c9997b588f022b2ef3a0012c/spec/support/star_wars_schema.rb#L111)
+
+## Todo
+
+- [ ] pluralIdentifyingRootField
+
+## More Resources
+
+- [`graphql`](https://github.com/rmosolgo/graphql-ruby) Ruby gem
+- [`graphql-relay-js`](https://github.com/graphql/graphql-relay-js) JavaScript helpers for GraphQL and Relay

data/lib/graphql/definition_helpers/defined_by_config/definition_config.rb

@@ -0,0 +1,17 @@
+module GraphQL
+  module DefinitionHelpers
+    module DefinedByConfig
+      class DefinitionConfig
+        # Wraps a field definition with a ConnectionField
+        def connection(name, type = nil, desc = nil, property: nil, &block)
+          underlying_field = field(name, type, desc, property: property, &block)
+          connection_field = GraphQL::Relay::ConnectionField.create(underlying_field)
+          fields[name.to_s] = connection_field
+        end
+
+        alias :return_field :field
+        alias :return_fields :fields
+      end
+    end
+  end
+end

data/lib/graphql/relay.rb

@@ -0,0 +1,12 @@
+require 'base64'
+require 'graphql/definition_helpers/defined_by_config/definition_config'
+require 'graphql/relay/node'
+require 'graphql/relay/page_info'
+require 'graphql/relay/edge'
+require 'graphql/relay/connection_type'
+require 'graphql/relay/base_connection'
+require 'graphql/relay/array_connection'
+require 'graphql/relay/relation_connection'
+require 'graphql/relay/global_id_field'
+require 'graphql/relay/connection_field'
+require 'graphql/relay/mutation'

data/lib/graphql/relay/array_connection.rb

@@ -0,0 +1,48 @@
+module GraphQL
+  module Relay
+    class ArrayConnection < BaseConnection
+      # Just to encode data in the cursor, use something that won't conflict
+      CURSOR_SEPARATOR = "---"
+
+      def cursor_from_node(item)
+        idx = sliced_nodes.find_index(item)
+        cursor_parts = [(order || "none"), idx]
+        Base64.strict_encode64(cursor_parts.join(CURSOR_SEPARATOR))
+      end
+
+      private
+
+      # apply first / last limit results
+      def paged_nodes
+        @paged_nodes = begin
+          items = sliced_nodes
+          first && items = items.first(first)
+          last && items.length > last && items.last(last)
+          items
+        end
+      end
+
+      # Apply cursors to edges
+      def sliced_nodes
+        @sliced_nodes ||= begin
+          items = object
+          if order
+            # Remove possible direction marker:
+            order_name = order.sub(/^-/, '')
+            items = items.sort_by { |item| item.public_send(order_name) }
+            order.start_with?("-") && items = items.reverse
+          end
+          after && items = items[(1 + index_from_cursor(after))..-1]
+          before && items = items[0..(index_from_cursor(before) - 1)]
+          items
+        end
+      end
+
+      def index_from_cursor(cursor)
+        decoded = Base64.decode64(cursor)
+        order, index = decoded.split(CURSOR_SEPARATOR)
+        index.to_i
+      end
+    end
+  end
+end

data/lib/graphql/relay/base_connection.rb

@@ -0,0 +1,83 @@
+module GraphQL
+  module Relay
+    # Subclasses must implement:
+    #   - {#cursor_from_node}, which returns an opaque cursor for the given item
+    #   - {#sliced_edges}, which slices by `before` & `after`
+    #   - {#paged_edges}, which applies `first` & `last` limits
+    #
+    # In a subclass, you have access to
+    #   - {#object}, the object which the connection will wrap
+    #   - {#first}, {#after}, {#last}, {#before} (arguments passed to the field)
+    #
+    class BaseConnection
+      # Just to encode data in the cursor, use something that won't conflict
+      CURSOR_SEPARATOR = "---"
+
+      # Create a connection which exposes edges of this type
+      def self.create_type(wrapped_type)
+        edge_type = Edge.create_type(wrapped_type)
+
+        connection_type = ConnectionType.define do
+          name("#{wrapped_type.name}Connection")
+          field :edges, types[edge_type]
+          field :pageInfo, PageInfo, property: :page_info
+        end
+
+        connection_type.connection_class = self
+
+        connection_type
+      end
+
+      attr_reader :object, :arguments
+
+      def initialize(object, arguments)
+        @object = object
+        @arguments = arguments
+      end
+
+      # Provide easy access to provided arguments:
+      METHODS_FROM_ARGUMENTS = [:first, :after, :last, :before, :order]
+
+      METHODS_FROM_ARGUMENTS.each do |arg_name|
+        define_method(arg_name) do
+          arguments[arg_name]
+        end
+      end
+
+      # Wrap nodes in {Edge}s so they expose cursors.
+      def edges
+        @edges ||= paged_nodes.map { |item| Edge.new(item, self) }
+      end
+
+      # Support the `pageInfo` field
+      def page_info
+        self
+      end
+
+      # Used by `pageInfo`
+      def has_next_page
+        first && sliced_nodes.count > first
+      end
+
+      # Used by `pageInfo`
+      def has_previous_page
+        last && sliced_nodes.count > last
+      end
+
+      # An opaque operation which returns a connection-specific cursor.
+      def cursor_from_node(object)
+        raise NotImplementedError, "must return a cursor for this object/connection pair"
+      end
+
+      private
+
+      def paged_nodes
+        raise NotImplementedError, "must items for this connection after paging"
+      end
+
+      def sliced_nodes
+        raise NotImplementedError, "must all items for this connection after chopping off first and last"
+      end
+    end
+  end
+end

data/lib/graphql/relay/connection_field.rb

@@ -0,0 +1,23 @@
+module GraphQL
+  module Relay
+    # The best way to make these is with the connection helper,
+    # @see {GraphQL::DefinitionHelpers::DefinedByConfig::DefinitionConfig}
+    class ConnectionField
+      def self.create(underlying_field)
+        field = GraphQL::Field.define do
+          argument :first, types.Int
+          argument :after, types.String
+          argument :last, types.Int
+          argument :before, types.String
+          argument :order, types.String
+
+          type(-> { underlying_field.type })
+          resolve -> (obj, args, ctx) {
+            items = underlying_field.resolve(obj, args, ctx)
+            underlying_field.type.connection_class.new(items, args)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/connection_type.rb

@@ -0,0 +1,10 @@
+module GraphQL
+  module Relay
+    # An ObjectType which also stores its {#connection_class}
+    class ConnectionType < GraphQL::ObjectType
+      defined_by_config :name, :fields, :interfaces
+      # @return [Class] A subclass of {BaseConnection}
+      attr_accessor :connection_class
+    end
+  end
+end

data/lib/graphql/relay/edge.rb

@@ -0,0 +1,26 @@
+module GraphQL
+  module Relay
+    # Mostly an internal concern.
+    #
+    # Wraps an object as a `node`, and exposes a connection-specific `cursor`.
+    class Edge < GraphQL::ObjectType
+      attr_reader :node
+      def initialize(node, connection)
+        @node = node
+        @connection = connection
+      end
+
+      def cursor
+        @cursor ||= @connection.cursor_from_node(node)
+      end
+
+      def self.create_type(wrapped_type)
+        GraphQL::ObjectType.define do
+          name("#{wrapped_type.name}Edge")
+          field :node, wrapped_type
+          field :cursor, !types.String
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/global_id_field.rb

@@ -0,0 +1,18 @@
+module GraphQL
+  module Relay
+    # @example Create a field that returns the global ID for an object
+    #   RestaurantType = GraphQL::ObjectType.define do
+    #     name "Restaurant"
+    #     field :id, field: GraphQL::Relay::GlobalIdField.new("Restaurant")
+    #   end
+    class GlobalIdField < GraphQL::Field
+      def initialize(type_name, property: :id)
+        self.arguments = {}
+        self.type = !GraphQL::ID_TYPE
+        self.resolve = -> (obj, args, ctx) {
+          Node.to_global_id(type_name, obj.public_send(property))
+        }
+      end
+    end
+  end
+end

data/lib/graphql/relay/mutation.rb

@@ -0,0 +1,128 @@
+module GraphQL
+  module Relay
+    # Define a Relay mutation:
+    #   - give it a name (used for derived inputs & outputs)
+    #   - declare its inputs
+    #   - declare its outputs
+    #   - declare the mutation procedure
+    #
+    # `resolve` should return a hash with a key for each of the `return_field`s
+    #
+    # Inputs will also contain a `clientMutationId`
+    #
+    # @example Updating the name of an item
+    #   UpdateNameMutation = GraphQL::Relay::Mutation.define do
+    #     name "UpdateName"
+    #
+    #     input_field :name, !types.String
+    #     input_field :itemId, !types.ID
+    #
+    #     return_field :item, Item
+    #
+    #     resolve -> (inputs, ctx) {
+    #       item = Item.find_by_id(inputs[:id])
+    #       item.update(name: inputs[:name])
+    #       {item: item}
+    #     }
+    #   end
+    #
+    #   MutationType = GraphQL::ObjectType.define do
+    #     # The mutation object exposes a field:
+    #     field :updateName, UpdateNameMutation.field
+    #   end
+    #
+    #   # Then query it:
+    #   query_string = %|
+    #     mutation updateName {
+    #       updateName(input: {itemId: 1, name: "new name", clientMutationId: "1234"}) {
+    #         item { name }
+    #         clientMutationId
+    #     }|
+    #
+    #    GraphQL::Query.new(MySchema, query_string).result
+    #    # {"data" => {
+    #    #   "updateName" => {
+    #    #     "item" => { "name" => "new name"},
+    #    #     "clientMutationId" => "1234"
+    #    #   }
+    #    # }}
+    #
+    class Mutation
+      include GraphQL::DefinitionHelpers::DefinedByConfig
+      defined_by_config :name, :description, :return_fields, :input_fields, :resolve
+      attr_accessor :name, :description, :return_fields, :input_fields
+
+      def resolve=(proc)
+        @resolve_proc = proc
+      end
+
+      def field
+        @field ||= begin
+          field_return_type = self.return_type
+          field_input_type = self.input_type
+          field_resolve_proc = -> (obj, args, ctx){
+            results_hash = @resolve_proc.call(args[:input], ctx)
+            Result.new(arguments: args, result: results_hash)
+          }
+          GraphQL::Field.define do
+            type(field_return_type)
+            argument :input, !field_input_type
+            resolve(field_resolve_proc)
+          end
+        end
+      end
+
+      def return_type
+        @return_type ||= begin
+          mutation_name = name
+          type_name = "#{mutation_name}Payload"
+          type_fields = return_fields
+          GraphQL::ObjectType.define do
+            name(type_name)
+            description("Autogenerated return type of #{mutation_name}")
+            field :clientMutationId, !types.String
+            type_fields.each do |name, field_obj|
+              field name, field: field_obj
+            end
+          end
+        end
+      end
+
+      def input_type
+        @input_type ||= begin
+          mutation_name = name
+          type_name = "#{mutation_name}Input"
+          type_fields = input_fields
+          GraphQL::InputObjectType.define do
+            name(type_name)
+            description("Autogenerated input type of #{mutation_name}")
+            input_field :clientMutationId, !types.String
+            type_fields.each do |name, field_obj|
+              input_field name, field_obj.type, field_obj.description, default_value: field_obj.default_value
+            end
+          end
+        end
+      end
+
+      class Result
+        attr_reader :arguments, :result
+        def initialize(arguments:, result:)
+          @arguments = arguments
+          @result = result
+        end
+
+        def clientMutationId
+          arguments[:clientMutationId]
+        end
+
+        def method_missing(name, *args, &block)
+          if result.key?(name)
+            result[name]
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/node.rb

@@ -0,0 +1,64 @@
+require 'singleton'
+module GraphQL
+  module Relay
+    # To get a `NodeField` and `NodeInterface`,
+    # define an object that responds to:
+    #   - object_from_id
+    #   - type_from_object
+    # and pass it to `Node.create`
+    #
+    class Node
+      include Singleton
+
+      # Allows you to call methods on the class
+      def self.method_missing(method_name, *args, &block)
+        if instance.respond_to?(method_name)
+          instance.send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      # Return interface and field using implementation
+      def create(implementation)
+        interface = create_interface(implementation)
+        field = create_field(implementation, interface)
+        [interface, field]
+      end
+
+      # Create a global ID for type-name & ID
+      # (This is an opaque transform)
+      def to_global_id(type_name, id)
+        Base64.strict_encode64("#{type_name}-#{id}")
+      end
+
+      # Get type-name & ID from global ID
+      # (This reverts the opaque transform)
+      def from_global_id(global_id)
+        Base64.decode64(global_id).split("-")
+      end
+
+      private
+
+      def create_interface(implementation)
+        GraphQL::InterfaceType.define do
+          name "Node"
+          field :id, !types.ID
+          resolve_type -> (obj) {
+            implementation.type_from_object(obj)
+          }
+        end
+      end
+
+      def create_field(implementation, interface)
+        GraphQL::Field.define do
+          type(interface)
+          argument :id, !types.ID
+          resolve -> (obj, args, ctx) {
+            implementation.object_from_id(args[:id])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/page_info.rb

@@ -0,0 +1,11 @@
+module GraphQL
+  module Relay
+    # Wrap a Connection and expose its page info
+    PageInfo = GraphQL::ObjectType.define do
+      name("PageInfo")
+      description("Metadata about a connection")
+      field :hasNextPage, !types.Boolean, property: :has_next_page
+      field :hasPreviousPage, !types.Boolean, property: :has_previous_page
+    end
+  end
+end

data/lib/graphql/relay/relation_connection.rb

@@ -0,0 +1,70 @@
+module GraphQL
+  module Relay
+    class RelationConnection < BaseConnection
+      def cursor_from_node(item)
+        order_value = item.public_send(order_name)
+        cursor_parts = [order, order_value]
+        Base64.strict_encode64(cursor_parts.join(CURSOR_SEPARATOR))
+      end
+
+      def order
+        @order ||= (super || "id")
+      end
+
+
+      private
+
+      # apply first / last limit results
+      def paged_nodes
+        @paged_nodes = begin
+          items = sliced_nodes
+          first && items = items.first(first)
+          last && items.length > last && items.last(last)
+          items
+        end
+      end
+
+      # Apply cursors to edges
+      def sliced_nodes
+        @sliced_nodes ||= begin
+          items = object
+
+          if order
+            items = items.order(order_name => order_direction)
+          end
+
+          if after
+            _o, order_value = slice_from_cursor(after)
+            sort_query = order_direction == :asc ? "? > ?" : "? < ?"
+            puts sort_query, order_name, order_value
+            items = items.where(sort_query, order_name, order_value)
+          end
+
+          if before
+            _o, order_value = slice_from_cursor(before)
+            sort_query = order_direction == :asc ? "? < ?" : "? > ?"
+            p [sort_query, order_name, order_value]
+            items = items.where(sort_query, order_name, order_value)
+          end
+
+          items
+        end
+      end
+
+      def slice_from_cursor(cursor)
+        decoded = Base64.decode64(cursor)
+        order, order_value = decoded.split(CURSOR_SEPARATOR)
+      end
+
+      # Remove possible direction marker:
+      def order_name
+        @order_name ||= order.sub(/^-/, '')
+      end
+
+      # Check for direction marker
+      def order_direction
+        @order_direction ||= order.start_with?("-") ? :desc : :asc
+      end
+    end
+  end
+end

data/lib/graphql/relay/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Relay
+    VERSION = '0.1.0'
+  end
+end

data/spec/graphql/relay/array_connection_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::ArrayConnection do
+  def get_names(result)
+    ships = result["data"]["rebels"]["ships"]["edges"]
+    names = ships.map { |e| e["node"]["name"] }
+  end
+  describe "results" do
+    let(:query_string) {%|
+      query getShips($first: Int, $after: String, $last: Int, $before: String, $order: String){
+        rebels {
+          ships(first: $first, after: $after, last: $last, before: $before, order: $order) {
+            edges {
+              cursor
+              node {
+                name
+              }
+            }
+            pageInfo {
+              hasNextPage
+            }
+          }
+        }
+      }
+    |}
+    it 'limits the result' do
+      result = query(query_string, "first" => 2)
+      number_of_ships = get_names(result).length
+      assert_equal(2, number_of_ships)
+      assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+
+      result = query(query_string, "first" => 3)
+      number_of_ships = get_names(result).length
+      assert_equal(3, number_of_ships)
+    end
+
+    it 'provides pageInfo' do
+      result = query(query_string, "first" => 2)
+      assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+
+      result = query(query_string, "first" => 100)
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+    end
+
+    it 'slices the result' do
+      result = query(query_string, "first" => 3)
+      assert_equal(["X-Wing", "Y-Wing", "A-Wing"], get_names(result))
+
+      # After the last result, find the next 2:
+      last_cursor = result["data"]["rebels"]["ships"]["edges"].last["cursor"]
+
+      result = query(query_string, "after" => last_cursor, "first" => 2)
+      assert_equal(["Millenium Falcon", "Home One"], get_names(result))
+
+      result = query(query_string, "before" => last_cursor, "last" => 2)
+      assert_equal(["X-Wing", "Y-Wing"], get_names(result))
+    end
+
+    it 'paginates with order' do
+      result = query(query_string, "first" => 2, "order" => "name")
+      assert_equal(["A-Wing", "Home One"], get_names(result))
+
+      # After the last result, find the next 2:
+      last_cursor = result["data"]["rebels"]["ships"]["edges"].last["cursor"]
+
+      result = query(query_string, "after" => last_cursor, "first" => 2, "order" => "name")
+      assert_equal(["Millenium Falcon", "X-Wing"], get_names(result))
+    end
+
+    it 'paginates with reverse order' do
+      result = query(query_string, "first" => 2, "order" => "-name")
+      assert_equal(["Y-Wing", "X-Wing"], get_names(result))
+    end
+  end
+end

data/spec/graphql/relay/mutation_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::Mutation do
+  let(:query_string) {%|
+    mutation addBagel {
+      introduceShip(input: {shipName: "Bagel", factionId: "1", clientMutationId: "1234"}) {
+        clientMutationId
+        ship { name, id }
+        faction { name }
+      }
+    }
+  |}
+  let(:introspect) {%|
+    {
+      __schema {
+        types { name, fields { name } }
+      }
+    }
+  |}
+
+  it "returns the result & clientMutationId" do
+    result = query(query_string)
+    expected = {"data" => {
+      "introduceShip" => {
+        "clientMutationId" => "1234",
+        "ship" => {
+          "name" => "Bagel",
+          "id" => GraphQL::Relay::Node.to_global_id("Ship", "9"),
+        },
+        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
+      }
+    }}
+  end
+end

data/spec/graphql/relay/node_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::Node do
+  describe 'NodeField' do
+    it 'finds objects by id' do
+      global_id = GraphQL::Relay::Node.to_global_id("Ship", "1")
+      result = query(%|{node(id: "#{global_id}") { id, ... on Ship { name } }}|)
+      expected = {"data" => {
+        "node" => {
+          "id" =>   global_id,
+          "name" => "X-Wing"
+        }
+      }}
+      assert_equal(expected, result)
+    end
+  end
+
+  describe 'to_global_id / from_global_id ' do
+    it 'Converts typename and ID to and from ID' do
+      global_id = GraphQL::Relay::Node.to_global_id("SomeType", "123")
+      type_name, id = GraphQL::Relay::Node.from_global_id(global_id)
+      assert_equal("SomeType", type_name)
+      assert_equal("123", id)
+    end
+  end
+end

data/spec/graphql/relay/relation_connection_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::RelationConnection do
+  def get_names(result)
+    ships = result["data"]["empire"]["bases"]["edges"]
+    names = ships.map { |e| e["node"]["name"] }
+  end
+
+  def get_page_info(result)
+    result["data"]["empire"]["bases"]["pageInfo"]
+  end
+
+  describe "results" do
+    let(:query_string) {%|
+      query getShips($first: Int, $after: String, $last: Int, $before: String, $order: String){
+        empire {
+          bases(first: $first, after: $after, last: $last, before: $before, order: $order) {
+            edges {
+              cursor
+              node {
+                name
+              }
+            }
+            pageInfo {
+              hasNextPage
+            }
+          }
+        }
+      }
+    |}
+    it 'limits the result' do
+      result = query(query_string, "first" => 2)
+      assert_equal(2, get_names(result).length)
+
+      result = query(query_string, "first" => 3)
+      assert_equal(3, get_names(result).length)
+    end
+
+    it 'provides pageInfo' do
+      result = query(query_string, "first" => 2)
+      assert_equal(true, get_page_info(result)["hasNextPage"])
+
+      result = query(query_string, "first" => 100)
+      assert_equal(false, get_page_info(result)["hasNextPage"])
+    end
+
+    it 'slices the result' do
+      result = query(query_string, "first" => 2)
+      assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+      # After the last result, find the next 2:
+      last_cursor = result["data"]["empire"]["bases"]["edges"].last["cursor"]
+
+      result = query(query_string, "after" => last_cursor, "first" => 2)
+      assert_equal(["Headquarters"], get_names(result))
+
+      result = query(query_string, "before" => last_cursor, "last" => 2)
+      assert_equal(["Death Star"], get_names(result))
+    end
+
+    it 'paginates with order' do
+      result = query(query_string, "first" => 2, "order" => "name")
+      assert_equal(["Death Star", "Headquarters"], get_names(result))
+
+      # After the last result, find the next 2:
+      last_cursor = result["data"]["empire"]["bases"]["edges"].last["cursor"]
+
+      result = query(query_string, "after" => last_cursor, "first" => 2, "order" => "name")
+      assert_equal(["Shield Generator"], get_names(result))
+    end
+
+    it 'paginates with reverse order' do
+      result = query(query_string, "first" => 2, "order" => "-name")
+      assert_equal(["Shield Generator", "Headquarters"], get_names(result))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+require "sqlite3"
+require "active_record"
+require "graphql"
+require "graphql/relay"
+require "minitest/autorun"
+require "minitest/focus"
+require "minitest/reporters"
+require 'pry'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+# Filter out Minitest backtrace while allowing backtrace from other libraries to be shown.
+Minitest.backtrace_filter = Minitest::BacktraceFilter.new
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+
+def query(string, variables={})
+  GraphQL::Query.new(StarWarsSchema, string, variables: variables).result
+end

data/spec/support/star_wars_data.rb

@@ -0,0 +1,68 @@
+
+names = [
+  'X-Wing',
+  'Y-Wing',
+  'A-Wing',
+  'Millenium Falcon',
+  'Home One',
+  'TIE Fighter',
+  'TIE Interceptor',
+  'Executor',
+]
+
+rebels  = OpenStruct.new({
+  id: '1',
+  name: 'Alliance to Restore the Republic',
+  ships:  ['1', '2', '3', '4', '5'],
+  bases: ['11', '12']
+})
+
+
+empire = OpenStruct.new({
+  id: '2',
+  name: 'Galactic Empire',
+  ships: ['6', '7', '8'],
+  bases: ['13', '14', '15']
+})
+
+## Set up "Bases" in ActiveRecord
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+  create_table :bases do |t|
+    t.column :name, :string
+    t.column :planet, :string
+    t.column :faction_id, :integer
+  end
+end
+
+class Base < ActiveRecord::Base
+end
+
+Base.create(id: 11, name: "Yavin", planet: "Yavin 4", faction_id: 1)
+Base.create(id: 12, name: "Echo Base", planet: "Hoth", faction_id: 1)
+Base.create(id: 13, name: "Death Star", planet: nil, faction_id: 2)
+Base.create(id: 14, name: "Shield Generator", planet: "Endor", faction_id: 2)
+Base.create(id: 15, name: "Headquarters", planet: "Coruscant", faction_id: 2)
+
+STAR_WARS_DATA = {
+  "Faction" => {
+    "1" => rebels,
+    "2" => empire,
+  },
+  "Ship" => names.each_with_index.reduce({}) do |memo, (name, idx)|
+    id = (idx + 1).to_s
+    memo[id] = OpenStruct.new(name: name, id: id)
+    memo
+  end
+}
+
+def STAR_WARS_DATA.create_ship(name, faction_id)
+  new_id = (self["Ship"].keys.map(&:to_i).max + 1).to_s
+  new_ship = OpenStruct.new(id: new_id, name: name)
+  self["Ship"][new_id] = new_ship
+  self["Faction"][faction_id]["ships"] << new_id
+  new_ship
+end

data/spec/support/star_wars_schema.rb

@@ -0,0 +1,114 @@
+# Taken from graphql-relay-js
+# https://github.com/graphql/graphql-relay-js/blob/master/src/__tests__/starWarsSchema.js
+
+class NodeImplementation
+  def object_from_id(id)
+    type_name, id = GraphQL::Relay::Node.from_global_id(id)
+    STAR_WARS_DATA[type_name][id]
+  end
+
+  def type_from_object(object)
+    STAR_WARS_DATA["Faction"].values.include?(object) ? Faction : Ship
+  end
+end
+
+NodeInterface, NodeField = GraphQL::Relay::Node.create(NodeImplementation.new)
+
+
+
+Ship = GraphQL::ObjectType.define do
+  name "Ship"
+  interfaces [NodeInterface]
+  field :id, field: GraphQL::Relay::GlobalIdField.new("Ship")
+  field :name, types.String
+end
+
+# Define a connection which will wrap an array:
+ShipConnection = GraphQL::Relay::ArrayConnection.create_type(Ship)
+
+
+BaseType = GraphQL::ObjectType.define do
+  name "Base"
+  interfaces [NodeInterface]
+  field :id, field: GraphQL::Relay::GlobalIdField.new("Base")
+  field :name, types.String
+  field :planet, types.String
+end
+
+# Define a connection which will wrap an array:
+BaseConnection = GraphQL::Relay::RelationConnection.create_type(BaseType)
+
+
+
+Faction = GraphQL::ObjectType.define do
+  name "Faction"
+  interfaces [NodeInterface]
+  field :id, field: GraphQL::Relay::GlobalIdField.new("Faction")
+  field :name, types.String
+  connection :ships, ShipConnection do
+    # Resolve field should return an Array, the Connection
+    # will do the rest!
+    resolve -> (obj, args, ctx) {
+      obj.ships.map {|ship_id| STAR_WARS_DATA["Ship"][ship_id] }
+    }
+  end
+  connection :bases, BaseConnection do
+    # Resolve field should return an Array, the Connection
+    # will do the rest!
+    resolve -> (obj, args, ctx) {
+      Base.where(id: obj.bases)
+    }
+  end
+end
+
+# Define a mutation. It will also:
+#   - define a derived InputObjectType
+#   - define a derived ObjectType (for return)
+#   - define a field, accessible from {Mutation#field}
+#
+# The resolve proc takes `inputs, ctx`, where:
+#   - `inputs` has the keys defined with `input_field`
+#   - `ctx` is the Query context (like normal fields)
+#
+# Notice that you leave out clientMutationId.
+IntroduceShipMutation = GraphQL::Relay::Mutation.define do
+  # Used as the root for derived types:
+  name "IntroduceShip"
+
+  # Nested under `input` in the query:
+  input_field :shipName, !types.String
+  input_field :factionId, !types.ID
+
+  # Result may have access to these fields:
+  return_field :ship, Ship
+  return_field :faction, Faction
+
+  # Here's the mutation operation:
+  resolve -> (inputs, ctx) {
+    faction_id = inputs["factionId"]
+    ship = STAR_WARS_DATA.create_ship(inputs["shipName"], faction_id)
+    faction = STAR_WARS_DATA["Faction"][faction_id]
+    { ship: ship, faction: faction }
+  }
+end
+
+QueryType = GraphQL::ObjectType.define do
+  name "Query"
+  field :rebels, Faction do
+    resolve -> (obj, args, ctx) { STAR_WARS_DATA["Faction"]["1"]}
+  end
+
+  field :empire, Faction do
+    resolve -> (obj, args, ctx) { STAR_WARS_DATA["Faction"]["2"]}
+  end
+
+  field :node, field: NodeField
+end
+
+MutationType = GraphQL::ObjectType.define do
+  name "Mutation"
+  # The mutation object exposes a field:
+  field :introduceShip, field: IntroduceShipMutation.field
+end
+
+StarWarsSchema = GraphQL::Schema.new(query: QueryType, mutation: MutationType)

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: graphql-relay
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Mosolgo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Connections, UUID, etc?
+email:
+- rdmosolgo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/graphql/definition_helpers/defined_by_config/definition_config.rb
+- lib/graphql/relay.rb
+- lib/graphql/relay/array_connection.rb
+- lib/graphql/relay/base_connection.rb
+- lib/graphql/relay/connection_field.rb
+- lib/graphql/relay/connection_type.rb
+- lib/graphql/relay/edge.rb
+- lib/graphql/relay/global_id_field.rb
+- lib/graphql/relay/mutation.rb
+- lib/graphql/relay/node.rb
+- lib/graphql/relay/page_info.rb
+- lib/graphql/relay/relation_connection.rb
+- lib/graphql/relay/version.rb
+- spec/graphql/relay/array_connection_spec.rb
+- spec/graphql/relay/mutation_spec.rb
+- spec/graphql/relay/node_spec.rb
+- spec/graphql/relay/relation_connection_spec.rb
+- spec/spec_helper.rb
+- spec/support/star_wars_data.rb
+- spec/support/star_wars_schema.rb
+homepage: http://github.com/rmosolgo/graphql-relay-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Relay helpers for GraphQL
+test_files:
+- spec/graphql/relay/array_connection_spec.rb
+- spec/graphql/relay/mutation_spec.rb
+- spec/graphql/relay/node_spec.rb
+- spec/graphql/relay/relation_connection_spec.rb
+- spec/spec_helper.rb
+- spec/support/star_wars_data.rb
+- spec/support/star_wars_schema.rb