graphql-relay 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6284053a13755747eea7b324a8c95c6acac7a2ce
-  data.tar.gz: 12fd8d7abd63b48100a90212fc2386762129fdd9
+  metadata.gz: 4a86533b3e1bc7030fe0016ee41e9492e25cc597
+  data.tar.gz: d80d3d7006d8f37a7f208b49c2fd3dc5f78081c2
 SHA512:
-  metadata.gz: 0df6bf1e5c4f2ac0d10e8f1328159fab1c802e969c26c3c274c3e1075b525aca788b21f24cb8cd1a0ae636838143d00d9c4e83441b94735431ae08c00c288165
-  data.tar.gz: 4a9e932f728d71c8763c072b4d6e419b1d37d5da5607fe68deb7bf87a4c1850ae19ba1328d2a0483accedfcea35ab4e4820d8d76202891363e85ed46cbae3121
+  metadata.gz: 9c0f624fba3f5e81724bdf73459cf72747f8f6f8ca9a569e15b99cd4391a72d25d098ec6f1c3932ce794d4d0db33b1ea2ec0e2292d11e7b79070989de2a0da09
+  data.tar.gz: 04e49ec547a0930ac9b26a54b5a7107dd5a61fe1f758449915c58b4ea7f4c2bbc4917a49e77fff80f0497a478b83624e1b97461dffc21694fec20d8fa6f55e03

data/README.md

@@ -1,6 +1,7 @@
 # graphql-relay
 
 [![Gem Version](https://badge.fury.io/rb/graphql-relay.svg)](http://badge.fury.io/rb/graphql-relay)
+[![Build Status](https://travis-ci.org/rmosolgo/graphql-relay-ruby.svg?branch=master)](https://travis-ci.org/rmosolgo/graphql-relay-ruby)
 [![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)
 
@@ -24,24 +25,19 @@ 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)
+Then, you can add global id fields to your types with `global_id_field` definition helper.
+ [Example](https://github.com/rmosolgo/graphql-relay-ruby/blob/master/spec/support/star_wars_schema.rb#L29)
 
 ### 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)
+Connections will provide arguments, pagination and `pageInfo` for `Array`s or `ActiveRecord::Relation`s. You can use the `connection` definition helper.
 
 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
+  - Call `#connection_type` on an `ObjectType` for the field's return type (eg, `ShipType.connection_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)
+[Example 1](https://github.com/rmosolgo/graphql-relay-ruby/blob/master/spec/support/star_wars_schema.rb#L39-L51), [Example 2](https://github.com/rmosolgo/graphql-relay-ruby/blob/master/spec/support/star_wars_schema.rb#L52-L58)
 
 ### Mutations
 
@@ -69,7 +65,7 @@ Examples:
 
 ## Todo
 
-- [ ] pluralIdentifyingRootField
+- [ ] Fix `Node.create` -- make it return one object which exposes useful info
 
 ## More Resources
 

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

@@ -3,14 +3,39 @@ module GraphQL
     module DefinedByConfig
       class DefinitionConfig
         # Wraps a field definition with a ConnectionField
+        # - applies default fields
+        # - wraps the resolve proc to make a connection
+        #
         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)
+          # Wrap the given block to define the default args
+          definition_block = -> (config) {
+            argument :first, types.Int
+            argument :after, types.String
+            argument :last, types.Int
+            argument :before, types.String
+            argument :order, types.String
+            self.instance_eval(&block)
+          }
+          connection_field = field(name, type, desc, property: property, &definition_block)
+          # Wrap the defined resolve proc
+          # TODO: make a public API on GraphQL::Field to expose this proc
+          original_resolve = connection_field.instance_variable_get(:@resolve_proc)
+          connection_resolve = -> (obj, args, ctx) {
+            items = original_resolve.call(obj, args, ctx)
+            connection_class = GraphQL::Relay::BaseConnection.connection_for_items(items)
+            connection_class.new(items, args)
+          }
+          connection_field.resolve = connection_resolve
           fields[name.to_s] = connection_field
         end
 
         alias :return_field :field
         alias :return_fields :fields
+
+        def global_id_field(field_name)
+          name || raise("You must define the type's name before creating a GlobalIdField")
+          field(name, field: GraphQL::Relay::GlobalIdField.new(name))
+        end
       end
     end
   end

data/lib/graphql/object_type.rb

@@ -0,0 +1,7 @@
+module GraphQL
+  class ObjectType
+    def connection_type
+      @connection_type ||= GraphQL::Relay::BaseConnection.create_type(self)
+    end
+  end
+end

data/lib/graphql/relay.rb

@@ -1,12 +1,13 @@
 require 'base64'
+# MONKEY PATCHES 😬
 require 'graphql/definition_helpers/defined_by_config/definition_config'
+require_relative './object_type.rb'
+
 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

@@ -44,5 +44,6 @@ module GraphQL
         index.to_i
       end
     end
+    BaseConnection.register_connection_implementation(Array, ArrayConnection)
   end
 end

data/lib/graphql/relay/base_connection.rb

@@ -13,21 +13,41 @@ 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
+      CONNECTION_IMPLEMENTATIONS = {}
+
       # 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
+        connection_type = ObjectType.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
 
+      # @return [subclass of BaseConnection] a connection wrapping `items`
+      def self.connection_for_items(items)
+        implementation = CONNECTION_IMPLEMENTATIONS.find do |items_class, connection_class|
+          items.is_a?(items_class)
+        end
+        if implementation.nil?
+          raise("No connection implementation to wrap #{items.class}")
+        else
+          implementation[1]
+        end
+      end
+
+      # Add `connection_class` as the connection wrapper for `items_class`
+      # eg, `RelationConnection` is the implementation for `AR::Relation`
+      def self.register_connection_implementation(items_class, connection_class)
+        CONNECTION_IMPLEMENTATIONS[items_class] = connection_class
+      end
+
       attr_reader :object, :arguments
 
       def initialize(object, arguments)

data/lib/graphql/relay/relation_connection.rb

@@ -71,5 +71,8 @@ module GraphQL
         ["#{name} #{direction_marker} ?", value]
       end
     end
+    if defined?(ActiveRecord)
+      BaseConnection.register_connection_implementation(ActiveRecord::Relation, RelationConnection)
+    end
   end
 end

data/lib/graphql/relay/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Relay
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

data/spec/graphql/relay/array_connection_spec.rb

@@ -5,11 +5,15 @@ describe GraphQL::Relay::ArrayConnection do
     ships = result["data"]["rebels"]["ships"]["edges"]
     names = ships.map { |e| e["node"]["name"] }
   end
+
+  def get_last_cursor(result)
+    result["data"]["rebels"]["ships"]["edges"].last["cursor"]
+  end
   describe "results" do
     let(:query_string) {%|
-      query getShips($first: Int, $after: String, $last: Int, $before: String, $order: String){
+      query getShips($first: Int, $after: String, $last: Int, $before: String, $order: String, $nameIncludes: String){
         rebels {
-          ships(first: $first, after: $after, last: $last, before: $before, order: $order) {
+          ships(first: $first, after: $after, last: $last, before: $before, order: $order, nameIncludes: $nameIncludes) {
             edges {
               cursor
               node {
@@ -47,7 +51,7 @@ describe GraphQL::Relay::ArrayConnection do
       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"]
+      last_cursor = get_last_cursor(result)
 
       result = query(query_string, "after" => last_cursor, "first" => 2)
       assert_equal(["Millenium Falcon", "Home One"], get_names(result))
@@ -71,5 +75,16 @@ describe GraphQL::Relay::ArrayConnection do
       result = query(query_string, "first" => 2, "order" => "-name")
       assert_equal(["Y-Wing", "X-Wing"], get_names(result))
     end
+
+    it 'applies custom arguments' do
+      result = query(query_string, "nameIncludes" => "Wing", "first" => 2)
+      names = get_names(result)
+      assert_equal(2, names.length)
+
+      after = get_last_cursor(result)
+      result = query(query_string, "nameIncludes" => "Wing", "after" => after)
+      names = get_names(result)
+      assert_equal(1, names.length)
+    end
   end
 end

data/spec/graphql/relay/relation_connection_spec.rb

@@ -15,18 +15,22 @@ describe GraphQL::Relay::RelationConnection do
       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
-              }
-            }
+            ... basesConnection
             pageInfo {
               hasNextPage
             }
           }
         }
       }
+
+      fragment basesConnection on BaseConnection {
+        edges {
+          cursor
+          node {
+            name
+          }
+        }
+      }
     |}
     it 'limits the result' do
       result = query(query_string, "first" => 2)

data/spec/support/star_wars_schema.rb

@@ -23,36 +23,33 @@ Ship = GraphQL::ObjectType.define do
   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")
+  global_id_field :id
   field :name, types.String
   field :planet, types.String
 end
 
-# Define a connection which will wrap an ActiveRecord::Relation:
-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
+  connection :ships, Ship.connection_type 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] }
+      all_ships = obj.ships.map {|ship_id| STAR_WARS_DATA["Ship"][ship_id] }
+      if args[:nameIncludes]
+        all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
+      end
+      all_ships
     }
+    # You can define arguments here and use them in the connection
+    argument :nameIncludes, types.String
   end
-  connection :bases, BaseConnection do
+  connection :bases, BaseType.connection_type do
     # Resolve field should return an Array, the Connection
     # will do the rest!
     resolve -> (obj, args, ctx) {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-relay
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-24 00:00:00.000000000 Z
+date: 2015-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -188,11 +188,10 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/graphql/definition_helpers/defined_by_config/definition_config.rb
+- lib/graphql/object_type.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

data/lib/graphql/relay/connection_field.rb

@@ -1,23 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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