graphql-relay 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4cb7e4a30922d4db833bf738f058336298533802
-  data.tar.gz: 286be9492a0ada16bdeb48c37b70cc4f60c1ecd8
+  metadata.gz: e48e815c037e952c8d1e2a9f54379b5bfbce7ae8
+  data.tar.gz: 629bdf27a10511bdee0664304443b33f999581c9
 SHA512:
-  metadata.gz: 56f104a6b5bd5505fa5dee4fe4baee4d981c14284bdfe2afb7357fdb72384fe213b02899b68129806aff1a5a1d5044b9f57fd23672cbb9faf26f8caf2aca2ce4
-  data.tar.gz: 1be2fe49797910d14ff5dffa5a665a937c63c12a69136c6a9af3c94ccb42724e5c3d89a46740259a745ffc9302839612ba66a92de24d44123245534f1c205203
+  metadata.gz: 5b4a352c2405b890bc4a9b727f80f65f7f3e9c332162848b7fb41560147b4cf57597da9cc1739e47d15441f59528aa20ddba763201c5b58ffd50e1a1cedfaf71
+  data.tar.gz: d630722d99ee1c605bf55df1554d23912ac3f3bb545ef89dd9a24bbd1bf267af25a6838dbf5e22a8d606d764422271aae2a931c3f7beec7050e78ae63d687b84

data/README.md

@@ -87,6 +87,32 @@ QueryType = GraphQL::ObjectType.define do
 end
 ```
 
+#### Custom UUID Generation
+
+By default, `graphql-relay` uses `Base64.strict_encode64` to generate opaque global ids. You can modify this behavior by providing two configurations. They work together to encode and decode ids:
+
+```ruby
+NodeIdentification = GraphQL::Relay::GlobalNodeIdentification.define do
+  # ...
+
+  # Return a string for re-fetching this object
+  to_global_id -> (type_name, id) {
+    "#{type_name.downcase}/#{id}"
+  }
+
+  # Based on the incoming string, extract the type_name and id
+  from_global_id -> (global_id) {
+    id_parts  = global_id.split("/")
+    type_name = id_parts[0]
+    id        = id_parts[1]
+    # Return *both*:
+    type_name, id
+  }
+end
+```
+
+`graphql-relay` will use those procs for interacting with global ids.
+
 ### Connections
 
 Connections provide pagination and `pageInfo` for `Array`s or `ActiveRecord::Relation`s.
@@ -318,6 +344,11 @@ https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-
 
 ## Todo
 
+- Allow custom defined ID scheme
+- 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
+
 ## More Resources
 
 - [GraphQL Slack](http://graphql-slack.herokuapp.com), come join us in the `#ruby` channel!

data/lib/graphql/relay.rb

@@ -1,9 +1,9 @@
 require 'base64'
 require 'graphql'
 # MONKEY PATCHES 😬
-require 'graphql/relay/monkey_patches/definition_config'
 require 'graphql/relay/monkey_patches/base_type'
 
+require 'graphql/relay/define'
 require 'graphql/relay/global_node_identification'
 require 'graphql/relay/page_info'
 require 'graphql/relay/edge'
@@ -13,3 +13,9 @@ require 'graphql/relay/relation_connection'
 require 'graphql/relay/global_id_field'
 require 'graphql/relay/mutation'
 require 'graphql/relay/connection_field'
+
+# Accept Relay-specific definitions
+GraphQL::BaseType.accepts_definitions(
+  connection: GraphQL::Relay::Define::AssignConnection,
+  global_id_field: GraphQL::Relay::Define::AssignGlobalIdField,
+)

data/lib/graphql/relay/connection_field.rb

@@ -45,9 +45,6 @@ module GraphQL
       def self.get_connection_resolve(field_name, underlying_resolve, max_page_size: nil)
         -> (obj, args, ctx) {
           items = underlying_resolve.call(obj, args, ctx)
-          if items == GraphQL::Query::DEFAULT_RESOLVE
-            items = obj.public_send(field_name)
-          end
           connection_class = GraphQL::Relay::BaseConnection.connection_for_items(items)
           connection_class.new(items, args, max_page_size: max_page_size)
         }

data/lib/graphql/relay/define.rb

@@ -0,0 +1,20 @@
+module GraphQL
+  module Relay
+    module Define
+      module AssignConnection
+        def self.call(type_defn, name, type = nil, desc = nil, property: nil, max_page_size: nil, &block)
+          underlying_field = GraphQL::Define::AssignObjectField.call(type_defn, name, type, desc, property: property, &block)
+          connection_field = GraphQL::Relay::ConnectionField.create(underlying_field, max_page_size: max_page_size)
+          type_defn.fields[name.to_s] = connection_field
+        end
+      end
+
+      module AssignGlobalIdField
+        def self.call(type_defn, field_name)
+          type_defn.name || raise("You must define the type's name before creating a GlobalIdField")
+          GraphQL::Define::AssignObjectField.call(type_defn, field_name, field: GraphQL::Relay::GlobalIdField.new(type_defn.name))
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/global_node_identification.rb

@@ -3,20 +3,16 @@ module GraphQL
   module Relay
     # This object provides helpers for working with global IDs.
     # It's assumed you'll only have 1!
+    #
     # GlobalIdField depends on that, since it calls class methods
     # which delegate to the singleton instance.
+    #
     class GlobalNodeIdentification
-      class << self
-        attr_accessor :id_separator
-      end
-      self.id_separator = "-"
-
-      include GraphQL::DefinitionHelpers::DefinedByConfig
-      defined_by_config :object_from_id_proc, :type_from_object_proc
-      attr_accessor :object_from_id_proc, :type_from_object_proc
+      include GraphQL::Define::InstanceDefinable
+      accepts_definitions(:object_from_id, :type_from_object, :to_global_id, :from_global_id)
 
       class << self
-        attr_accessor :instance
+        attr_accessor :instance, :id_separator
         def new(*args, &block)
           @instance = super
         end
@@ -30,6 +26,13 @@ module GraphQL
         end
       end
 
+      self.id_separator = "-"
+
+      def initialize
+        @to_global_id_proc = DEFAULT_TO_GLOBAL_ID
+        @from_global_id_proc = DEFAULT_FROM_GLOBAL_ID
+      end
+
       # Returns `NodeInterface`, which all Relay types must implement
       def interface
         @interface ||= begin
@@ -56,20 +59,36 @@ module GraphQL
         end
       end
 
+      DEFAULT_TO_GLOBAL_ID = -> (type_name, id) {
+        id_str = id.to_s
+        if type_name.include?(self.id_separator) || id_str.include?(self.id_separator)
+          raise "to_global_id(#{type_name}, #{id}) contains reserved characters `#{self.id_separator}`"
+        end
+        Base64.strict_encode64([type_name, id_str].join(self.id_separator))
+      }
+
+      DEFAULT_FROM_GLOBAL_ID = -> (global_id) {
+        Base64.decode64(global_id).split(self.id_separator)
+      }
+
       # Create a global ID for type-name & ID
       # (This is an opaque transform)
       def to_global_id(type_name, id)
-        id_str = id.to_s
-        if type_name.include?(self.class.id_separator) || id_str.include?(self.class.id_separator)
-          raise "to_global_id(#{type_name}, #{id}) contains reserved characters `#{self.class.id_separator}`"
-        end
-        Base64.strict_encode64([type_name, id_str].join(self.class.id_separator))
+        @to_global_id_proc.call(type_name, id)
+      end
+
+      def to_global_id=(proc)
+        @to_global_id_proc = proc
       end
 
       # Get type-name & ID from global ID
       # (This reverts the opaque transform)
       def from_global_id(global_id)
-        Base64.decode64(global_id).split(self.class.id_separator)
+        @from_global_id_proc.call(global_id)
+      end
+
+      def from_global_id=(proc)
+        @from_global_id_proc = proc
       end
 
       # Use the provided config to
@@ -84,11 +103,19 @@ module GraphQL
         end
       end
 
+      def type_from_object=(proc)
+        @type_from_object_proc = proc
+      end
+
       # Use the provided config to
       # get an object from a UUID
       def object_from_id(id, ctx)
         @object_from_id_proc.call(id, ctx)
       end
+
+      def object_from_id=(proc)
+        @object_from_id_proc = proc
+      end
     end
   end
 end

data/lib/graphql/relay/mutation.rb

@@ -48,9 +48,23 @@ module GraphQL
     #    # }}
     #
     class Mutation
-      include GraphQL::DefinitionHelpers::DefinedByConfig
-      defined_by_config :name, :description, :return_fields, :input_fields, :resolve
-      attr_accessor :name, :description, :return_fields, :input_fields
+      include GraphQL::Define::InstanceDefinable
+      accepts_definitions(
+        :name, :description, :resolve,
+        input_field: GraphQL::Define::AssignArgument,
+        return_field: GraphQL::Define::AssignObjectField,
+      )
+      attr_accessor :name, :definition
+      attr_reader :fields, :arguments
+
+      # For backwards compat, but do we need this separate API?
+      alias :return_fields :fields
+      alias :input_fields :arguments
+
+      def initialize
+        @fields = {}
+        @arguments = {}
+      end
 
       def resolve=(proc)
         @resolve_proc = proc

data/lib/graphql/relay/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Relay
-    VERSION = '0.7.1'
+    VERSION = '0.8.0'
   end
 end

data/spec/graphql/relay/global_node_identification_spec.rb

@@ -75,6 +75,41 @@ describe GraphQL::Relay::GlobalNodeIdentification do
       }
       assert_includes err.message, "to_global_id(Best-Thing, 234) contains reserved characters `-`"
     end
+
+    describe "custom definitions" do
+      before do
+        @previous_global_node_id = GraphQL::Relay::GlobalNodeIdentification.instance
+        @new_node_id = GraphQL::Relay::GlobalNodeIdentification.define do
+          to_global_id -> (type_name, id) {
+            "#{type_name}/#{id}"
+          }
+
+          from_global_id -> (global_id) {
+            global_id.split("/")
+          }
+        end
+      end
+
+      after do
+        GraphQL::Relay::GlobalNodeIdentification.instance = @previous_global_node_id
+      end
+
+      describe "generating IDs" do
+        it "Applies custom-defined ID generation" do
+          result = query(%| { largestBase { id } }|)
+          generated_id = result["data"]["largestBase"]["id"]
+          assert_equal "Base/13", generated_id
+        end
+      end
+
+      describe "fetching by ID" do
+        it "Deconstructs the ID by the custom proc" do
+          result = query(%| { node(id: "Base/11") { ... on Base { name } } }|)
+          base_name = result["data"]["node"]["name"]
+          assert_equal "Yavin", base_name
+        end
+      end
+    end
   end
 
   describe "type_from_object" do

data/spec/support/star_wars_data.rb

@@ -59,7 +59,8 @@ STAR_WARS_DATA = {
     id = (idx + 1).to_s
     memo[id] = OpenStruct.new(name: name, id: id)
     memo
-  end
+  end,
+  "Base" => Hash.new { |h, k| h[k] = Base.find(k) }
 }
 
 def STAR_WARS_DATA.create_ship(name, faction_id)

data/spec/support/star_wars_schema.rb

@@ -8,13 +8,19 @@
 # See global_node_identification.rb for the full API.
 NodeIdentification = GraphQL::Relay::GlobalNodeIdentification.define do
   object_from_id -> (id, ctx) do
-    type_name, id = NodeIdentification.from_global_id(id)
+    # In a normal app, you could call `from_global_id` on your defined object
+    # type_name, id = NodeIdentification.from_global_id(id)
+    #
+    # But to support our testing setup, reach for the global:
+    type_name, id = GraphQL::Relay::GlobalNodeIdentification.from_global_id(id)
     STAR_WARS_DATA[type_name][id]
   end
 
   type_from_object -> (object) do
     if object == :test_error
       :not_a_type
+    elsif object.is_a?(Base)
+      BaseType
     else
       STAR_WARS_DATA["Faction"].values.include?(object) ? Faction : Ship
     end
@@ -133,6 +139,10 @@ QueryType = GraphQL::ObjectType.define do
     resolve -> (obj, args, ctx) { STAR_WARS_DATA["Faction"]["2"]}
   end
 
+  field :largestBase, BaseType do
+    resolve -> (obj, args, ctx) { Base.find(13) }
+  end
+
   field :node, field: NodeIdentification.field
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-relay
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-29 00:00:00.000000000 Z
+date: 2016-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.12'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -170,14 +170,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '11.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -205,11 +205,11 @@ files:
 - lib/graphql/relay/array_connection.rb
 - lib/graphql/relay/base_connection.rb
 - lib/graphql/relay/connection_field.rb
+- lib/graphql/relay/define.rb
 - lib/graphql/relay/edge.rb
 - lib/graphql/relay/global_id_field.rb
 - lib/graphql/relay/global_node_identification.rb
 - lib/graphql/relay/monkey_patches/base_type.rb
-- lib/graphql/relay/monkey_patches/definition_config.rb
 - lib/graphql/relay/mutation.rb
 - lib/graphql/relay/page_info.rb
 - lib/graphql/relay/relation_connection.rb

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

@@ -1,26 +0,0 @@
-class GraphQL::DefinitionHelpers::DefinedByConfig::DefinitionConfig
-  # Wraps a field definition with a ConnectionField
-  def connection(name, type = nil, desc = nil, property: nil, max_page_size: nil, &block)
-    underlying_field = field(name, type, desc, property: property, &block)
-    connection_field = GraphQL::Relay::ConnectionField.create(underlying_field, max_page_size: max_page_size)
-    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(field_name, field: GraphQL::Relay::GlobalIdField.new(name))
-  end
-
-  # Support GlobalNodeIdentification
-  attr_accessor :object_from_id_proc, :type_from_object_proc
-  def object_from_id(proc)
-    @object_from_id_proc = proc
-  end
-
-  def type_from_object(proc)
-    @type_from_object_proc = proc
-  end
-end