relay-rb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c976d6b1f308d77fad6f43623d821150b45df13
+  data.tar.gz: d396a7d982e23b6ca71bafbbdbc438b444c0ea6b
+SHA512:
+  metadata.gz: 914555d8c843092f3a6fbe1cec290ae032784a4296b32eaf1245d65429693a9305e2e5e5a55ac84f54ba2a45b38cd7fc1813105b6410c4ca452e3c0fc3c29651
+  data.tar.gz: 70c0950fcf1b438467aef315b0f572febb7c17609cc4e9d6e00a0f23ea338e5a1b58d10e3560520e4dc47c5224e9fd96899ac1a67df10ebfcd7f7cc76fbec079

data/Rakefile

@@ -0,0 +1,26 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Relay Ruby'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:test) do |test|
+  test.verbose      = false
+  test.rspec_opts   = %w[--color --format documentation]
+end
+
+task default: :test

data/lib/relay/connection/array.rb

@@ -0,0 +1,54 @@
+require 'base64'
+
+module Relay
+  module Connection
+
+    ARRAY_CONNECTION_PREFIX = 'arrayconnection'
+
+    Edge            = Struct.new('Edge', :cursor, :node)
+    PageInfo        = Struct.new('PageInfo', :startCursor, :endCursor, :hasPreviousPage, :hasNextPage)
+    ArrayConnection = Struct.new('ArrayConnection', :edges, :pageInfo)
+    EmptyConnection = ArrayConnection.new([], PageInfo.new(nil, nil, false, false))
+
+    def self.connection_from_array(data, args)
+      edges   = data.each_with_index.map { |item, i| Edge.new(offset_to_cursor(i), item) }
+
+      start   = [get_offset(args[:after], -1), -1].max + 1
+      finish  = [get_offset(args[:before], edges.size + 1), edges.size + 1].min
+
+      edges = edges.slice(start, finish)
+
+      return EmptyConnection if edges.size == 0
+
+      first_preslice_cursor = edges.first[:cursor]
+      last_preslice_cursor  = edges.last[:cursor]
+
+      edges = edges.slice(0, args[:first]) unless args[:first].nil?
+      egdes = edges.slice!(- args[:last], edges.size) unless args[:last].nil?
+
+      return EmptyConnection if edges.size == 0
+
+      ArrayConnection.new(edges, PageInfo.new(
+        edges.first[:cursor],
+        edges.last[:cursor],
+        edges.first[:cursor]  != first_preslice_cursor,
+        edges.last[:cursor]   != last_preslice_cursor
+      ))
+    end
+
+    def self.offset_to_cursor(index)
+      Base64.strict_encode64([ARRAY_CONNECTION_PREFIX, index].join(':'))
+    end
+
+    def self.cursor_to_offset(cursor)
+      Base64.strict_decode64(cursor).split(':').last.to_i
+    end
+
+    def self.get_offset(cursor, default_offset)
+      return default_offset unless cursor
+      offset = cursor_to_offset(cursor)
+      offset.nil? ? default_offset : offset
+    end
+
+  end
+end

data/lib/relay/connection/connection.rb

@@ -0,0 +1,78 @@
+require_relative 'array'
+
+module Relay
+  module Connection
+
+    ConnectionArguments = [
+      GraphQL::GraphQLArgument.new(:before, GraphQL::GraphQLString),
+      GraphQL::GraphQLArgument.new(:after, GraphQL::GraphQLString),
+      GraphQL::GraphQLArgument.new(:first, GraphQL::GraphQLInt),
+      GraphQL::GraphQLArgument.new(:last, GraphQL::GraphQLInt)
+    ]
+
+    class ConnectionConfiguration < GraphQL::Configuration::Base
+      slot :name,               String
+      slot :node_type,          GraphQL::GraphQLObjectType
+      slot :edge_fields,       [GraphQL::GraphQLField], singular: :edge_field
+      slot :connection_fields, [GraphQL::GraphQLField], singular: :connection_field
+    end
+
+    def self.connection_definitions(configuration)
+      name, node_type = configuration.name, configuration.node_type
+
+      edge_type = GraphQL::GraphQLObjectType.new do
+        name        name + 'Edge'
+        description 'An edge in a connection'
+
+        field :node, node_type do
+          description 'The item at the end of the edge'
+        end
+
+        field :cursor, ! GraphQL::GraphQLString do
+          description 'A cursor for use in pagination'
+        end
+
+        fields configuration.edge_fields
+      end
+
+      connection_type = GraphQL::GraphQLObjectType.new do
+        name          name + 'Connection'
+        description   'A connection to a list of items.'
+
+        field :pageInfo, !PageInfoType do
+          description 'Information to aid in pagination.'
+        end
+
+        field :edges, +edge_type do
+          description 'Information to aid in pagination.'
+        end
+
+        fields configuration.connection_fields
+      end
+
+      return edge_type, connection_type
+    end
+
+    PageInfoType = GraphQL::GraphQLObjectType.new do
+      name          'PageInfo'
+      description   'Information about pagination in a connection.'
+
+      field :hasNextPage, !GraphQL::GraphQLBoolean do
+        description 'When paginating forwards, are there more items?'
+      end
+
+      field :hasPreviousPage, !GraphQL::GraphQLBoolean do
+        description 'When paginating backwards, are there more items?'
+      end
+
+      field :startCursor, GraphQL::GraphQLString do
+        description 'When paginating backwards, the cursor to continue.'
+      end
+
+      field :endCursor, GraphQL::GraphQLString do
+        description 'When paginating forwards, the cursor to continue.'
+      end
+    end
+
+  end
+end

data/lib/relay/node/global_id_field.rb

@@ -0,0 +1,38 @@
+require 'graphql'
+
+module Relay
+
+
+  GLOBAL_ID_FIELD_DEFAULT_RESOLVE = -> (object) { object.id }
+
+  class GlobalIDFieldConfiguration < GraphQL::Configuration::Base
+    slot :name,       String, coerce: -> (v) { v.to_s }
+    slot :type_name,  String, coerce: -> (v) { v.to_s }
+    slot :resolve_id, Proc,   null: true
+  end
+
+
+  class GraphQL::GraphQLObjectTypeConfiguration
+
+    def global_id_field(*args, &block)
+      configuration = GlobalIDFieldConfiguration.new(*args, &block)
+
+      resolve_id = configuration.resolve_id || GLOBAL_ID_FIELD_DEFAULT_RESOLVE
+
+      global_id_field = GraphQL::GraphQLFieldConfiguration.new do
+        name configuration.name
+
+        type !GraphQL::GraphQLID
+
+        resolve lambda { |object|
+          Relay::Node.to_global_id(configuration.type_name, resolve_id.call(object))
+        }
+      end
+
+      field(global_id_field)
+    end
+
+  end
+
+
+end

data/lib/relay/node/plural_identifying_root_field.rb

@@ -0,0 +1,35 @@
+module Relay
+  module Node
+
+    class PluralIdentifyingRootFieldConfiguration < GraphQL::Configuration::Base
+      slot :name,                   String, coerce: -> (v) { v.to_s }
+      slot :input_type,             GraphQL::GraphQLInputType
+      slot :output_type,            GraphQL::GraphQLOutputType
+      slot :argument_name,          String, coerce: -> (v) { v.to_s }
+      slot :resolve_single_input,   Proc
+    end
+
+    class GraphQL::GraphQLObjectTypeConfiguration
+
+      def plural_identifying_root_field(*args, &block)
+        configuration = PluralIdentifyingRootFieldConfiguration.new(*args, &block)
+
+        plural_identifying_root_field = GraphQL::GraphQLFieldConfiguration.new do
+          name configuration.name
+
+          type +configuration.output_type
+
+          arg configuration.argument_name, !+!configuration.input_type
+
+          resolve lambda { |object, params|
+            params[configuration.argument_name.to_sym].map { |param| configuration.resolve_single_input.call(param) }
+          }
+        end
+
+        field(plural_identifying_root_field)
+      end
+
+    end
+
+  end
+end

data/lib/relay/node.rb

@@ -0,0 +1,50 @@
+require 'graphql'
+require 'base64'
+require_relative 'node/global_id_field'
+require_relative 'node/plural_identifying_root_field'
+
+module Relay
+
+  module Node
+
+    def self.definitions(fetcher, resolver)
+
+      interface = GraphQL::GraphQLInterfaceType.new do
+        name          'Node'
+        description   'An object with ID'
+
+        field         :id, ! GraphQL::GraphQLID do
+          description 'The id of the object'
+        end
+
+        resolve_type resolver
+      end
+
+      field = GraphQL::GraphQLField.new do
+        name          'node'
+        description   'Fetches an object given its ID'
+        type          interface
+
+        arg :id, ! GraphQL::GraphQLID do
+          description 'The ID of an object'
+        end
+
+        resolve lambda { |root, params, info, *args|
+          fetcher.call(params[:id], info)
+        }
+      end
+
+      { interface: interface, field: field }
+    end
+
+    def self.to_global_id(type, id)
+      Base64.strict_encode64([type, id].join(':'))
+    end
+
+    def self.from_global_id(global_id)
+      return Base64.strict_decode64(global_id).split(':')
+    end
+
+  end
+
+end

data/lib/relay/version.rb

@@ -0,0 +1,3 @@
+module Relay
+  VERSION = '0.0.1'
+end

data/lib/relay.rb

@@ -0,0 +1,6 @@
+require 'relay/node'
+require 'relay/version'
+require 'relay/connection/connection'
+
+module Relay
+end

data/spec/connection/connection_spec.rb

@@ -0,0 +1,85 @@
+require 'relay'
+
+RSpec.describe 'Relay Connection' do
+
+  User = Struct.new('UserInRelayConnection', :name)
+
+  Users = [
+    User.new('Dan'),
+    User.new('Nick'),
+    User.new('Lee'),
+    User.new('Joe'),
+    User.new('Tim')
+  ]
+
+  friend_edge, friend_connection = Relay::Connection.connection_definitions(
+    Relay::Connection::ConnectionConfiguration.new do
+      name        'Friend'
+      node_type   -> { ConnectionUserType }
+
+      edge_field :friendship_time, GraphQL::GraphQLString do
+        resolve -> { 'Yesterday' }
+      end
+
+      connection_field :total_count, GraphQL::GraphQLInt do
+        resolve -> { Users.size }
+      end
+    end
+  )
+
+  ConnectionUserType = GraphQL::GraphQLObjectType.new do
+    name 'User'
+
+    field :name, GraphQL::GraphQLString
+
+    field :friends do
+      type friend_connection
+      args Relay::Connection::ConnectionArguments
+      resolve lambda { |user, params|
+        Relay::Connection.connection_from_array(Users, params)
+      }
+    end
+  end
+
+  ConnectionQueryType = GraphQL::GraphQLObjectType.new do
+    name 'Query'
+
+    field :user, ConnectionUserType do
+      resolve -> { Users[0] }
+    end
+  end
+
+  ConnectionSchema = GraphQL::GraphQLSchema.new do
+    query ConnectionQueryType
+  end
+
+
+  def q1
+    %Q(
+      query FriendsQuery {
+        user {
+          name
+          friends(first: 2, after: "YXJyYXljb25uZWN0aW9uOjM=") {
+            total_count
+            edges {
+              friendship_time
+              cursor
+              node {
+                name
+              }
+            }
+          }
+        }
+      }
+    )
+  end
+
+
+  it "Should include connections and edge fields" do
+    document = GraphQL::Language.parse(q1)
+    executor = GraphQL::Executor.new(document, ConnectionSchema)
+    puts executor.execute({})
+  end
+
+
+end

data/spec/node/data.rb

@@ -0,0 +1,69 @@
+module Relay
+  module Node
+    module Data
+
+      UserStruct = Struct.new('User', :id, :name)
+
+      Users = {
+        '1' => UserStruct.new('1', 'John Doe'),
+        '2' => UserStruct.new('2', 'Jane Smith')
+      }
+
+      PhotoStruct = Struct.new('Photo', :id, :width)
+
+      Photos = {
+        '3' => PhotoStruct.new('3', 300),
+        '4' => PhotoStruct.new('4', 400)
+      }
+
+      fetcher = lambda { |id, info|
+        if Users[id.to_s]
+          return Users[id.to_s]
+        end
+        if Photos[id.to_s]
+          return Photos[id.to_s]
+        end
+      }
+
+      resolver = lambda { |root|
+        if Users[root.id.to_s]
+          return UserType
+        end
+
+        if Photos[root.id.to_s]
+          return PhotoType
+        end
+      }
+
+      definitions = Relay::Node.definitions(fetcher, resolver)
+
+      UserType = GraphQL::GraphQLObjectType.new do
+        name 'User'
+
+        field :id,    ! GraphQL::GraphQLID
+        field :name,    GraphQL::GraphQLString
+
+        interface definitions[:interface]
+      end
+
+      PhotoType = GraphQL::GraphQLObjectType.new do
+        name 'Photo'
+
+        field :id,    ! GraphQL::GraphQLID
+        field :width,   GraphQL::GraphQLInt
+
+        interface definitions[:interface]
+      end
+
+      QueryType = GraphQL::GraphQLObjectType.new do
+        name 'Query'
+
+        field definitions[:field]
+      end
+
+      Schema = GraphQL::GraphQLSchema.new do
+        query QueryType
+      end
+    end
+  end
+end

data/spec/node/data_global.rb

@@ -0,0 +1,78 @@
+module Relay
+  module Node
+    module DataGlobal
+
+      UserStruct = Struct.new('UserGlobal', :id, :name)
+
+      Users = {
+        '1' => UserStruct.new('1', 'John Doe'),
+        '2' => UserStruct.new('2', 'Jane Smith')
+      }
+
+      PhotoStruct = Struct.new('PhotoGlobal', :photo_id, :width)
+
+      Photos = {
+        '3' => PhotoStruct.new('3', 300),
+        '4' => PhotoStruct.new('4', 400)
+      }
+
+      fetcher = lambda { |id, *args|
+        type, id = Relay::Node.from_global_id(id)
+
+        case type
+        when 'User'
+          Users[id]
+        when 'Photo'
+          Photos[id]
+        end
+      }
+
+      resolver = lambda { |root|
+        case root
+        when UserStruct
+          UserType
+        when PhotoStruct
+          PhotoType
+        end
+      }
+
+      definitions = Relay::Node.definitions(fetcher, resolver)
+
+      UserType = GraphQL::GraphQLObjectType.new do
+        name 'User'
+
+        global_id_field :id, type_name: 'User'
+
+        field :name,    GraphQL::GraphQLString
+
+        interface definitions[:interface]
+      end
+
+      PhotoType = GraphQL::GraphQLObjectType.new do
+        name 'Photo'
+
+        global_id_field :id, type_name: 'Photo', resolve_id: -> (object) { object.photo_id }
+
+        field :width,   GraphQL::GraphQLInt
+
+        interface definitions[:interface]
+      end
+
+      QueryType = GraphQL::GraphQLObjectType.new do
+        name 'Query'
+
+        field definitions[:field]
+
+        field :all, + definitions[:interface] do
+          resolve lambda { |*args|
+            Users.values.concat(Photos.values)
+          }
+        end
+      end
+
+      Schema = GraphQL::GraphQLSchema.new do
+        query QueryType
+      end
+    end
+  end
+end

data/spec/node/node_global_spec.rb

@@ -0,0 +1,50 @@
+require 'relay'
+require_relative 'data_global'
+
+RSpec.describe 'Relay Node with Global ID' do
+
+  def schema
+    Relay::Node::DataGlobal::Schema
+  end
+
+  def all_q1
+    %Q{{
+      all {
+        id
+      }
+    }}
+  end
+
+  def all_q2
+    %Q{{
+      user: node(id: "VXNlcjox") {
+        id
+        ... on User {
+          name
+        }
+      }
+      photo: node(id: "UGhvdG86Mw==") {
+        id
+        ... on Photo {
+          width
+        }
+      }
+    }}
+  end
+
+
+  it "Should give different ids" do
+    expectations = {all: [{id: 'VXNlcjox'}, {id: 'VXNlcjoy'}, {id: 'UGhvdG86Mw=='}, {id: 'UGhvdG86NA=='}]}
+    document = GraphQL::Language.parse(all_q1)
+    executor = GraphQL::Executor.new(document, schema)
+    expect(executor.execute({})).to eq(expectations)
+  end
+
+  it "Should refetch ids" do
+    expectations = {user: {id: 'VXNlcjox', name: 'John Doe'}, photo: {id: 'UGhvdG86Mw==', width: 300}}
+    document = GraphQL::Language.parse(all_q2)
+    executor = GraphQL::Executor.new(document, schema)
+    expect(executor.execute({})).to eq(expectations)
+  end
+
+end

data/spec/node/node_plural_spec.rb

@@ -0,0 +1,51 @@
+require 'relay'
+
+RSpec.describe 'Relay Node Plural' do
+
+  UserType = GraphQL::GraphQLObjectType.new do
+    name 'User'
+
+    field :username,  GraphQL::GraphQLString
+    field :url,       GraphQL::GraphQLString
+  end
+
+  UserStruct = Struct.new('PluralUser', :username, :url)
+
+  QueryType = GraphQL::GraphQLObjectType.new do
+    name 'Query'
+
+    plural_identifying_root_field :usernames do
+      argument_name :usernames
+      input_type    GraphQL::GraphQLString
+      output_type   UserType
+
+      resolve_single_input lambda { |username, *args|
+        UserStruct.new(username, "www.facebook.com/#{username}")
+      }
+    end
+  end
+
+  Schema = GraphQL::GraphQLSchema.new do
+
+    query QueryType
+
+  end
+
+  def q1
+    %Q(
+      {
+        usernames(usernames: ["dschafer", "leebyron", "schrockn"]) {
+          username
+          url
+        }
+      }
+    )
+  end
+
+  it "Should allow fetching" do
+    document = GraphQL::Language.parse(q1)
+    executor = GraphQL::Executor.new(document, Schema)
+    puts executor.execute({})
+  end
+
+end