graphql-relay 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbc5dd733714ace5095fc3a5f9a7a465a046af0c
-  data.tar.gz: b609505dea93ea2d6a9e685e3ba379d80d35d286
+  metadata.gz: f9e0b75206216efdc87ad4a9d85f6032d89ea4ec
+  data.tar.gz: a8ed52c2debcd019a00f62f5ebe0eee3ebe17c63
 SHA512:
-  metadata.gz: 2e247f4e0963c80f99bebea7aae3788135cf12b63222478820ad5621d85583c2b5e53e5104c5d33b3be79ca4cbd3b623f98fbbc6ea7f94fd097f79f5d086bdc2
-  data.tar.gz: 65c4fe9c224c36bf0a687cbadfedbaac750a7178887b7aa86ee69894efc5f48c117ea8efb3eda037ce2a87a1ecf628328b94e05ed11d6e8a854fe60bb6d0fe73
+  metadata.gz: 34a25f845c250b77c5f7ecfc31aadbcacf0ac4f4ada1d102cfbeb687d29a4ddd983b0e32cedd20bb87f06d8dceef9099361936c99c56194c9156ce565b8ca674
+  data.tar.gz: bbd6a2a4f2def1b7eb981f9190a1291a5a2ba5999e3590f62c4a33c6c928fa1f1c81dd7edf1f9c4fe06540dc00a1a4116b048faad50f663c1c78d7a8da290f8a

data/README.md

@@ -5,7 +5,8 @@
 [![Code Climate](https://codeclimate.com/github/rmosolgo/graphql-relay-ruby/badges/gpa.svg)](https://codeclimate.com/github/rmosolgo/graphql-relay-ruby)
 [![Test Coverage](https://codeclimate.com/github/rmosolgo/graphql-relay-ruby/badges/coverage.svg)](https://codeclimate.com/github/rmosolgo/graphql-relay-ruby/coverage)
 
-Helpers for using [`graphql`](https://github.com/rmosolgo/graphql-ruby) with Relay.
+Helpers for using [`graphql`](https://github.com/rmosolgo/graphql-ruby) with Relay. Includes support for serving Relay connections from `Array`s, `ActiveRecord::Relation`s and `Sequel::Dataset`s.
+
 
 [API Documentation](http://www.rubydoc.info/github/rmosolgo/graphql-relay-ruby)
 ## Installation
@@ -115,7 +116,7 @@ end
 
 ### Connections
 
-Connections provide pagination and `pageInfo` for `Array`s or `ActiveRecord::Relation`s.
+Connections provide pagination and `pageInfo` for `Array`s,  `ActiveRecord::Relation`s or `Sequel::Dataset`s.
 
 #### Connection fields
 
@@ -136,6 +137,9 @@ You can also define custom arguments and a custom resolve function for connectio
 
 ```ruby
 connection :featured_comments, CommentType.connection_type do
+  # Use a name to disambiguate this from `CommentType.connection_type`
+  name "CommentConnectionWithSince"
+
   # Add an argument:
   argument :since, types.String
 
@@ -165,16 +169,119 @@ connection :featured_comments, CommentType.connection_type, max_page_size: 50
 You can customize a connection type with `.define_connection`:
 
 ```ruby
-PostType.define_connection do
+PostConnectionWithTotalCountType = PostType.define_connection do
   field :totalCount do
     type types.Int
     # `obj` is the Connection, `obj.object` is the collection of Posts
     resolve -> (obj, args, ctx) { obj.object.count }
   end
 end
+
+```
+
+Now, you can use `PostConnectionWithTotalCountType` to define a connection with the "totalCount" field:
+
+```ruby
+AuthorType = GraphQL::ObjectType.define do
+  # Use the custom connection type:
+  connection :posts, PostConnectionWithTotalCountType
+end
+```
+
+#### Custom edge types
+
+If you need custom fields on `edge`s, you can define an edge type and pass it to a connection:
+
+```ruby
+# Person => Membership => Team
+MembershipSinceEdgeType = BaseType.define_edge do
+  name "MembershipSinceEdge"
+  field :memberSince, types.Int, "The date that this person joined this team" do
+    resolve -> (obj, args, ctx) {
+      obj # => GraphQL::Relay::Edge instnce
+      person = obj.parent
+      team = obj.node
+      membership = Membership.where(person: person, team: team).first
+      membership.created_at.to_i
+    }
+  end
+end
 ```
 
-Now, `PostType.connection_type` will include a `totalCount` field.
+Then, pass the edge type when defining the connection type:
+
+```ruby
+TeamMembershipsConnectionType = TeamType.define_connection(edge_type: MembershipSinceEdgeType) do
+  # Use a name so it doesn't conflict with "TeamConnection"
+  name "TeamMembershipsConnection"
+end
+```
+
+Now, you can query custom fields on the `edge`:
+
+```graphql
+{
+  me {
+    teams {
+      edge {
+        memberSince     # <= Here's your custom field
+        node {
+          teamName: name
+        }
+      }
+    }
+  }
+}
+```
+
+#### Custom Edge classes
+
+For more robust custom edges, you can define a custom edge class. It will be `obj` in the edge type's resolve function. For example, to define a membership edge:
+
+```ruby
+# Make sure to familiarize yourself with GraphQL::Relay::Edge --
+# you have to avoid naming conflicts here!
+class MembershipSinceEdge < GraphQL::Relay::Edge
+  # Cache `membership` to avoid multiple DB queries
+  def membership
+    @membership ||= begin
+      # "parent" and "node" are passed in from the surrounding Connection,
+      # See `Edge#initialize` for details
+      person = self.parent
+      team = self.node
+      Membership.where(person: person, team: team).first
+    end
+  end
+
+  def member_since
+    membership.created_at.to_i
+  end
+
+  def leader?
+    membership.leader?
+  end
+end
+```
+
+Then, hook it up with custom edge type and custom connection type:
+
+```ruby
+# Person => Membership => Team
+MembershipSinceEdgeType = BaseType.define_edge do
+  name "MembershipSinceEdge"
+  field :memberSince, types.Int, "The date that this person joined this team", property: :member_since
+  field :isPrimary, types.Boolean, "Is this person the team leader?". property: :primary?
+  end
+end
+
+TeamMembershipsConnectionType = TeamType.define_connection(
+    edge_class: MembershipSinceEdge,
+    edge_type: MembershipSinceEdgeType,
+  ) do
+  # Use a name so it doesn't conflict with "TeamConnection"
+  name "TeamMembershipsConnection"
+end
+```
 
 #### Connection objects
 
@@ -237,7 +344,6 @@ field = GraphQL::Field.new
 connection_field = GraphQL::Relay::ConnectionField.create(field)
 ```
 
-
 ### Mutations
 
 Mutations allow Relay to mutate your system. They conform to a strict API which makes them predictable to the client.
@@ -342,7 +448,6 @@ https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-
 
 ## Todo
 
-- Allow custom edge fields (per connection type)
 - `GlobalNodeIdentification.to_global_id` should receive the type name and _object_, not `id`. (Or, maintain the "`type_name, id` in, `type_name, id` out" pattern?)
 - Make GlobalId a property of the schema, not a global
 - Reduce duplication in ArrayConnection / RelationConnection

data/lib/graphql/relay.rb

@@ -7,12 +7,14 @@ require 'graphql/relay/define'
 require 'graphql/relay/global_node_identification'
 require 'graphql/relay/page_info'
 require 'graphql/relay/edge'
+require 'graphql/relay/edge_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/mutation'
 require 'graphql/relay/connection_field'
+require 'graphql/relay/connection_type'
 
 # Accept Relay-specific definitions
 GraphQL::BaseType.accepts_definitions(

data/lib/graphql/relay/base_connection.rb

@@ -14,24 +14,10 @@ module GraphQL
       # Just to encode data in the cursor, use something that won't conflict
       CURSOR_SEPARATOR = "---"
 
-      # Map of collection classes -> connection_classes
-      # eg Array -> ArrayConnection
+      # Map of collection class names -> connection_classes
+      # eg {"Array" => ArrayConnection}
       CONNECTION_IMPLEMENTATIONS = {}
 
-      # Create a connection which exposes edges of this type
-      def self.create_type(wrapped_type, &block)
-        edge_type = wrapped_type.edge_type
-
-        connection_type = ObjectType.define do
-          name("#{wrapped_type.name}Connection")
-          field :edges, types[edge_type]
-          field :pageInfo, PageInfo, property: :page_info
-          block && instance_eval(&block)
-        end
-
-        connection_type
-      end
-
       # Find a connection implementation suitable for exposing `items`
       #
       # @param [Object] A collection of items (eg, Array, AR::Relation)
@@ -61,16 +47,18 @@ module GraphQL
         CONNECTION_IMPLEMENTATIONS[items_class.name] = connection_class
       end
 
-      attr_reader :object, :arguments, :max_page_size
+      attr_reader :object, :arguments, :max_page_size, :parent
 
       # Make a connection, wrapping `object`
       # @param The collection of results
       # @param Query arguments
       # @param max_page_size [Int] The maximum number of results to return
-      def initialize(object, arguments, max_page_size: nil)
+      # @param parent [Object] The object which this collection belongs to
+      def initialize(object, arguments, max_page_size: nil, parent: nil)
         @object = object
         @arguments = arguments
         @max_page_size = max_page_size
+        @parent = parent
       end
 
       # Provide easy access to provided arguments:
@@ -92,9 +80,10 @@ module GraphQL
         end
       end
 
-      # Wrap nodes in {Edge}s so they expose cursors.
-      def edges
-        @edges ||= paged_nodes.map { |item| Edge.new(item, self) }
+      # These are the items to render for this connection,
+      # probably wrapped by {GraphQL::Relay::Edge}
+      def edge_nodes
+        @edge_nodes ||= paged_nodes
       end
 
       # Support the `pageInfo` field

data/lib/graphql/relay/connection_type.rb

@@ -0,0 +1,25 @@
+module GraphQL
+  module Relay
+    module ConnectionType
+      # Create a connection which exposes edges of this type
+      def self.create_type(wrapped_type, edge_type: nil, edge_class: nil, &block)
+        edge_type ||= wrapped_type.edge_type
+        edge_class ||= GraphQL::Relay::Edge
+        connection_type_name = "#{wrapped_type.name}Connection"
+
+        connection_type = ObjectType.define do
+          name(connection_type_name)
+          field :edges, types[edge_type] do
+            resolve -> (obj, args, ctx) {
+              obj.edge_nodes.map { |item| edge_class.new(item, obj) }
+            }
+          end
+          field :pageInfo, PageInfo, property: :page_info
+          block && instance_eval(&block)
+        end
+
+        connection_type
+      end
+    end
+  end
+end

data/lib/graphql/relay/edge.rb

@@ -4,22 +4,19 @@ module GraphQL
     #
     # Wraps an object as a `node`, and exposes a connection-specific `cursor`.
     class Edge < GraphQL::ObjectType
-      attr_reader :node
+      attr_reader :node, :parent, :connection
       def initialize(node, connection)
         @node = node
         @connection = connection
+        @parent = parent
       end
 
       def cursor
-        @cursor ||= @connection.cursor_from_node(node)
+        @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
+      def parent
+        @parent ||= connection.parent
       end
     end
   end

data/lib/graphql/relay/edge_type.rb

@@ -0,0 +1,14 @@
+module GraphQL
+  module Relay
+    module EdgeType
+      def self.create_type(wrapped_type, name: nil, &block)
+        GraphQL::ObjectType.define do
+          name("#{wrapped_type.name}Edge")
+          field :node, wrapped_type
+          field :cursor, !types.String
+          block && instance_eval(&block)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/monkey_patches/base_type.rb

@@ -1,16 +1,21 @@
 class GraphQL::BaseType
+  # Get the default connection type for this object type
   def connection_type
     @connection_type ||= define_connection
   end
 
+  # Define a custom connection type for this object type
+  def define_connection(**kwargs, &block)
+    GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
+  end
+
+  # Get the default edge type for this object type
   def edge_type
-    @edge_type ||= GraphQL::Relay::Edge.create_type(self)
+    @edge_type ||= define_edge
   end
 
-  def define_connection(&block)
-    if !@connection_type.nil?
-      raise("#{name}'s connection type was already defined, can't redefine it!")
-    end
-    @connection_type = GraphQL::Relay::BaseConnection.create_type(self, &block)
+  # Define a custom edge type for this object type
+  def define_edge(**kwargs, &block)
+    GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
   end
 end

data/lib/graphql/relay/mutation.rb

@@ -8,7 +8,7 @@ module GraphQL
     #
     # `resolve` should return a hash with a key for each of the `return_field`s
     #
-    # Inputs will also contain a `clientMutationId`
+    # Inputs may also contain a `clientMutationId`
     #
     # @example Updating the name of an item
     #   UpdateNameMutation = GraphQL::Relay::Mutation.define do
@@ -94,7 +94,7 @@ module GraphQL
           GraphQL::ObjectType.define do
             name(type_name)
             description("Autogenerated return type of #{mutation_name}")
-            field :clientMutationId, !types.String
+            field :clientMutationId, types.String
             type_fields.each do |name, field_obj|
               field name, field: field_obj
             end
@@ -110,7 +110,7 @@ module GraphQL
           GraphQL::InputObjectType.define do
             name(type_name)
             description("Autogenerated input type of #{mutation_name}")
-            input_field :clientMutationId, !types.String
+            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

data/lib/graphql/relay/relation_connection.rb

@@ -1,5 +1,9 @@
 module GraphQL
   module Relay
+    # A connection implementation to expose SQL collection objects.
+    # It works for:
+    # - `ActiveRecord::Relation`
+    # - `Sequel::Dataset`
     class RelationConnection < BaseConnection
       def cursor_from_node(item)
         offset = starting_offset + paged_nodes_array.index(item) + 1
@@ -93,5 +97,8 @@ module GraphQL
     if defined?(ActiveRecord)
       BaseConnection.register_connection_implementation(ActiveRecord::Relation, RelationConnection)
     end
+    if defined?(Sequel)
+      BaseConnection.register_connection_implementation(Sequel::Dataset, RelationConnection)
+    end
   end
 end

data/lib/graphql/relay/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Relay
-    VERSION = "0.10.0"
+    VERSION = "0.11.0"
   end
 end

data/spec/graphql/relay/connection_type_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe GraphQL::Relay::ConnectionType do
+  describe ".create_type" do
+    describe "connections with custom Edge classes / EdgeTypes" do
+      let(:query_string) {%|
+        {
+          rebels {
+            basesWithCustomEdge {
+              totalCountTimes100
+              edges {
+                upcasedName
+                edgeClassName
+                node {
+                  name
+                }
+              }
+            }
+          }
+        }
+      |}
+
+      it "uses the custom edge and custom connection" do
+        result = query(query_string)
+        bases = result["data"]["rebels"]["basesWithCustomEdge"]
+        assert_equal 200, bases["totalCountTimes100"]
+        assert_equal ["YAVIN", "ECHO BASE"] , bases["edges"].map { |e| e["upcasedName"] }
+        assert_equal ["Yavin", "Echo Base"] , bases["edges"].map { |e| e["node"]["name"] }
+        assert_equal ["CustomBaseEdge", "CustomBaseEdge"] , bases["edges"].map { |e| e["edgeClassName"] }
+      end
+    end
+  end
+end

data/spec/graphql/relay/mutation_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe GraphQL::Relay::Mutation do
   let(:query_string) {%|
-    mutation addBagel {
-      introduceShip(input: {shipName: "Bagel", factionId: "1", clientMutationId: "1234"}) {
+    mutation addBagel($clientMutationId: String) {
+      introduceShip(input: {shipName: "Bagel", factionId: "1", clientMutationId: $clientMutationId}) {
         clientMutationId
         ship { name, id }
         faction { name }
@@ -18,8 +18,13 @@ describe GraphQL::Relay::Mutation do
     }
   |}
 
+  after do
+    STAR_WARS_DATA["Ship"].delete("9")
+    STAR_WARS_DATA["Faction"]["1"]["ships"].delete("9")
+  end
+
   it "returns the result & clientMutationId" do
-    result = query(query_string)
+    result = query(query_string, "clientMutationId" => "1234")
     expected = {"data" => {
       "introduceShip" => {
         "clientMutationId" => "1234",
@@ -31,8 +36,20 @@ describe GraphQL::Relay::Mutation do
       }
     }}
     assert_equal(expected, result)
-    # Cleanup:
-    STAR_WARS_DATA["Ship"].delete("9")
-    STAR_WARS_DATA["Faction"]["1"]["ships"].delete("9")
+  end
+
+  it "doesn't require a clientMutationId to perform mutations" do
+    result = query(query_string)
+    expected = {"data" => {
+      "introduceShip" => {
+        "clientMutationId" => nil,
+        "ship" => {
+          "name" => "Bagel",
+          "id" => NodeIdentification.to_global_id("Ship", "9"),
+        },
+        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
+      }
+    }}
+    assert_equal(expected, result)
   end
 end

data/spec/graphql/relay/relation_connection_spec.rb

@@ -20,7 +20,7 @@ describe GraphQL::Relay::RelationConnection do
         }
       }
 
-      fragment basesConnection on BaseConnection {
+      fragment basesConnection on BasesConnectionWithTotalCount {
         totalCount,
         edges {
           cursor
@@ -160,7 +160,7 @@ describe GraphQL::Relay::RelationConnection do
       query getBases {
         empire {
           basesByName(first: 30) { ... basesFields }
-          bases(first: 30) { ... basesFields }
+          bases(first: 30) { ... basesFields2 }
         }
       }
       fragment basesFields on BaseConnection {
@@ -170,6 +170,13 @@ describe GraphQL::Relay::RelationConnection do
           }
         }
       }
+      fragment basesFields2 on BasesConnectionWithTotalCount {
+        edges {
+          node {
+            name
+          }
+        }
+      }
     |}
 
     def get_names(result, field_name)
@@ -179,7 +186,6 @@ describe GraphQL::Relay::RelationConnection do
 
     it "applies the default value" do
       result = query(query_string)
-
       bases_by_id   = ["Death Star", "Shield Generator", "Headquarters"]
       bases_by_name = ["Death Star", "Headquarters", "Shield Generator"]
 
@@ -187,4 +193,93 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal(bases_by_name, get_names(result, "basesByName"))
     end
   end
+
+  describe "with a Sequel::Dataset" do
+    def get_names(result)
+      ships = result["data"]["empire"]["basesAsSequelDataset"]["edges"]
+      names = ships.map { |e| e["node"]["name"] }
+    end
+
+    def get_last_cursor(result)
+      result["data"]["empire"]["basesAsSequelDataset"]["edges"].last["cursor"]
+    end
+
+    describe "results" do
+      let(:query_string) {%|
+        query getShips($first: Int, $after: String, $last: Int, $before: String,  $nameIncludes: String){
+          empire {
+            basesAsSequelDataset(first: $first, after: $after, last: $last, before: $before, nameIncludes: $nameIncludes) {
+              ... basesConnection
+            }
+          }
+        }
+
+        fragment basesConnection on BasesConnectionWithTotalCount {
+          totalCount,
+          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 custom fileds on the connection type' do
+        result = query(query_string, "first" => 2)
+        assert_equal(
+          Base.where(faction_id: 2).count,
+          result["data"]["empire"]["basesAsSequelDataset"]["totalCount"]
+        )
+      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 = get_last_cursor(result)
+
+        result = query(query_string, "after" => last_cursor, "first" => 2)
+        assert_equal(["Headquarters"], get_names(result))
+
+        last_cursor = get_last_cursor(result)
+
+        result = query(query_string, "before" => last_cursor, "last" => 1)
+        assert_equal(["Shield Generator"], get_names(result))
+
+        result = query(query_string, "before" => last_cursor, "last" => 2)
+        assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+        result = query(query_string, "before" => last_cursor, "last" => 10)
+        assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+      end
+
+      it "applies custom arguments" do
+        result = query(query_string, "first" => 1, "nameIncludes" => "ea")
+        assert_equal(["Death Star"], get_names(result))
+
+        after = get_last_cursor(result)
+
+        result = query(query_string, "first" => 2, "nameIncludes" => "ea", "after" => after )
+        assert_equal(["Headquarters"], get_names(result))
+        before = get_last_cursor(result)
+
+        result = query(query_string, "last" => 1, "nameIncludes" => "ea", "before" => before)
+        assert_equal(["Death Star"], get_names(result))
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ require "codeclimate-test-reporter"
 CodeClimate::TestReporter.start
 require "sqlite3"
 require "active_record"
+require "sequel"
 require "graphql/relay"
 require "minitest/autorun"
 require "minitest/focus"
@@ -16,5 +17,5 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 
 def query(string, variables={})
-  GraphQL::Query.new(StarWarsSchema, string, variables: variables, debug: true).result
+  GraphQL::Query.new(StarWarsSchema, string, variables: variables).result
 end

data/spec/support/star_wars_data.rb

@@ -10,9 +10,10 @@ names = [
   'Executor',
 ]
 
-## Set up "Bases" in ActiveRecord
 # ActiveRecord::Base.logger = Logger.new(STDOUT)
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+`rm -f ./_test_.db`
+# Set up "Bases" in ActiveRecord
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: "./_test_.db")
 
 ActiveRecord::Schema.define do
   self.verbose = false
@@ -32,6 +33,11 @@ Base.create!(name: "Death Star", planet: nil, faction_id: 2)
 Base.create!(name: "Shield Generator", planet: "Endor", faction_id: 2)
 Base.create!(name: "Headquarters", planet: "Coruscant", faction_id: 2)
 
+# Also, set up Bases with Sequel
+DB = Sequel.sqlite("./_test_.db")
+class SequelBase < Sequel::Model(:bases)
+end
+
 rebels  = OpenStruct.new({
   id: '1',
   name: 'Alliance to Restore the Republic',

data/spec/support/star_wars_schema.rb

@@ -47,15 +47,38 @@ BaseType = GraphQL::ObjectType.define do
   field :planet, types.String
 end
 
-# Define a connection which will wrap an ActiveRecord::Relation.
-# We use an optional block to add fields to the connection type:
-BaseType.define_connection do
+# Use an optional block to add fields to the connection type:
+BaseConnectionWithTotalCountType = BaseType.define_connection do
+  name "BasesConnectionWithTotalCount"
   field :totalCount do
     type types.Int
     resolve -> (obj, args, ctx) { obj.object.count }
   end
 end
 
+class CustomBaseEdge < GraphQL::Relay::Edge
+  def upcased_name
+    node.name.upcase
+  end
+end
+
+CustomBaseEdgeType = BaseType.define_edge do
+  name "CustomBaseEdge"
+  field :upcasedName, types.String, property: :upcased_name
+  field :edgeClassName, types.String do
+    resolve -> (obj, args, ctx) { obj.class.name }
+  end
+end
+
+CustomEdgeBaseConnectionType = BaseType.define_connection(edge_class: CustomBaseEdge, edge_type: CustomBaseEdgeType) do
+  name "CustomEdgeBaseConnection"
+
+  field :totalCountTimes100 do
+    type types.Int
+    resolve -> (obj, args, ctx) { obj.object.count * 100 }
+  end
+end
+
 
 Faction = GraphQL::ObjectType.define do
   name "Faction"
@@ -75,7 +98,7 @@ Faction = GraphQL::ObjectType.define do
     # You can define arguments here and use them in the connection
     argument :nameIncludes, types.String
   end
-  connection :bases, BaseType.connection_type do
+  connection :bases, BaseConnectionWithTotalCountType do
     # Resolve field should return an Array, the Connection
     # will do the rest!
     resolve -> (obj, args, ctx) {
@@ -107,6 +130,19 @@ Faction = GraphQL::ObjectType.define do
   connection :basesWithMaxLimitArray, BaseType.connection_type, max_page_size: 2 do
     resolve -> (object, args, context) { Base.all.to_a }
   end
+
+  connection :basesAsSequelDataset, BaseConnectionWithTotalCountType do
+    argument :nameIncludes, types.String
+    resolve -> (obj, args, ctx) {
+      all_bases = SequelBase.where(faction_id: obj.id)
+      if args[:nameIncludes]
+        all_bases = all_bases.where("name LIKE ?", "%#{args[:nameIncludes]}%")
+      end
+      all_bases
+    }
+  end
+
+  connection :basesWithCustomEdge, CustomEdgeBaseConnectionType, property: :bases
 end
 
 # Define a mutation. It will also:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-relay
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-31 00:00:00.000000000 Z
+date: 2016-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -178,6 +178,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  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: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -206,8 +220,10 @@ files:
 - 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/define.rb
 - lib/graphql/relay/edge.rb
+- lib/graphql/relay/edge_type.rb
 - lib/graphql/relay/global_id_field.rb
 - lib/graphql/relay/global_node_identification.rb
 - lib/graphql/relay/monkey_patches/base_type.rb
@@ -216,6 +232,7 @@ files:
 - lib/graphql/relay/relation_connection.rb
 - lib/graphql/relay/version.rb
 - spec/graphql/relay/array_connection_spec.rb
+- spec/graphql/relay/connection_type_spec.rb
 - spec/graphql/relay/global_node_identification_spec.rb
 - spec/graphql/relay/mutation_spec.rb
 - spec/graphql/relay/page_info_spec.rb
@@ -249,6 +266,7 @@ specification_version: 4
 summary: Relay helpers for GraphQL
 test_files:
 - spec/graphql/relay/array_connection_spec.rb
+- spec/graphql/relay/connection_type_spec.rb
 - spec/graphql/relay/global_node_identification_spec.rb
 - spec/graphql/relay/mutation_spec.rb
 - spec/graphql/relay/page_info_spec.rb