graphql 0.17.2 → 0.18.0

data/lib/graphql/relay/connection_field.rb

@@ -0,0 +1,54 @@
+module GraphQL
+  module Relay
+    # Provided a GraphQL field which returns a collection of items,
+    # `ConnectionField.create` modifies that field to expose those items
+    # as a collection.
+    #
+    # The original resolve proc is used to fetch items,
+    # then a connection implementation is fetched with {BaseConnection.connection_for_items}.
+    class ConnectionField
+      ARGUMENT_DEFINITIONS = [
+          ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
+          ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified global ID."],
+          ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
+          ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified global ID."],
+        ]
+
+      DEFAULT_ARGUMENTS = ARGUMENT_DEFINITIONS.reduce({}) do |memo, arg_defn|
+        argument = GraphQL::Argument.new
+        name, type, description = arg_defn
+        argument.name = name
+        argument.type = type
+        argument.description = description
+        memo[argument.name.to_s] = argument
+        memo
+      end
+
+      # Turn A GraphQL::Field into a connection by:
+      # - Merging in the default arguments
+      # - Transforming its resolve function to return a connection object
+      # @param [GraphQL::Field] A field which returns items to be wrapped as a connection
+      # @param max_page_size [Integer] The maximum number of items which may be requested (if a larger page is requested, it is limited to this number)
+      # @return [GraphQL::Field] A field which serves a connections
+      def self.create(underlying_field, max_page_size: nil)
+        underlying_field.arguments = DEFAULT_ARGUMENTS.merge(underlying_field.arguments)
+        original_resolve = underlying_field.resolve_proc
+        underlying_field.resolve = get_connection_resolve(underlying_field.name, original_resolve, max_page_size: max_page_size)
+        underlying_field
+      end
+
+      private
+
+      # Wrap the original resolve proc
+      # so you capture its value, then wrap it in a
+      # connection implementation
+      def self.get_connection_resolve(field_name, underlying_resolve, max_page_size: nil)
+        -> (obj, args, ctx) {
+          items = underlying_resolve.call(obj, args, ctx)
+          connection_class = GraphQL::Relay::BaseConnection.connection_for_items(items)
+          connection_class.new(items, args, max_page_size: max_page_size, parent: obj)
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+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, :connection
+      def initialize(node, connection)
+        @node = node
+        @connection = connection
+      end
+
+      def cursor
+        @cursor ||= connection.cursor_from_node(node)
+      end
+
+      def parent
+        @parent ||= connection.parent
+      end
+    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/global_id_resolve.rb

@@ -0,0 +1,15 @@
+module GraphQL
+  module Relay
+    class GlobalIdResolve
+      def initialize(type_name:, property:)
+        @property = property
+        @type_name = type_name
+      end
+
+      def call(obj, args, ctx)
+        id_value = obj.public_send(@property)
+        ctx.query.schema.node_identification.to_global_id(@type_name, id_value)
+      end
+    end
+  end
+end

data/lib/graphql/relay/global_node_identification.rb

@@ -0,0 +1,124 @@
+require 'singleton'
+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
+      include GraphQL::Define::InstanceDefinable
+      accepts_definitions(:object_from_id, :type_from_object, :to_global_id, :from_global_id, :description)
+      lazy_defined_attr_accessor :description
+
+      class << self
+        attr_accessor :id_separator
+      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
+          ensure_defined
+          ident = self
+          GraphQL::InterfaceType.define do
+            name "Node"
+            field :id, !types.ID
+            resolve_type -> (obj, schema) {
+              ident.type_from_object(obj)
+            }
+          end
+        end
+      end
+
+      # Returns a field for finding objects from a global ID, which Relay needs
+      def field
+        ensure_defined
+        ident = self
+        GraphQL::Field.define do
+          type(ident.interface)
+          argument :id, !types.ID
+          resolve -> (obj, args, ctx) {
+            ctx.query.schema.node_identification.object_from_id(args[:id], ctx)
+          }
+          description ident.description
+        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)
+        ensure_defined
+        @to_global_id_proc.call(type_name, id)
+      end
+
+      def to_global_id=(proc)
+        ensure_defined
+        @to_global_id_proc = proc
+      end
+
+      # Get type-name & ID from global ID
+      # (This reverts the opaque transform)
+      def from_global_id(global_id)
+        ensure_defined
+        @from_global_id_proc.call(global_id)
+      end
+
+      def from_global_id=(proc)
+        ensure_defined
+        @from_global_id_proc = proc
+      end
+
+      # Use the provided config to
+      # get a type for a given object
+      def type_from_object(object)
+        ensure_defined
+        type_result = @type_from_object_proc.call(object)
+        if type_result.nil?
+          nil
+        elsif !type_result.is_a?(GraphQL::BaseType)
+          type_str = "#{type_result} (#{type_result.class.name})"
+          raise "type_from_object(#{object}) returned #{type_str}, but it should return a GraphQL type"
+        else
+          type_result
+        end
+      end
+
+      def type_from_object=(proc)
+        ensure_defined
+        @type_from_object_proc = proc
+      end
+
+      # Use the provided config to
+      # get an object from a UUID
+      def object_from_id(id, ctx)
+        ensure_defined
+        @object_from_id_proc.call(id, ctx)
+      end
+
+      def object_from_id=(proc)
+        ensure_defined
+        @object_from_id_proc = proc
+      end
+    end
+  end
+end

data/lib/graphql/relay/mutation.rb

@@ -0,0 +1,146 @@
+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 may 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, ItemType
+    #
+    #     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, field: 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::Define::InstanceDefinable
+      accepts_definitions(
+        :name, :description, :resolve,
+        input_field: GraphQL::Define::AssignArgument,
+        return_field: GraphQL::Define::AssignObjectField,
+      )
+      lazy_defined_attr_accessor :name, :description
+      lazy_defined_attr_accessor :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)
+        ensure_defined
+        @resolve_proc = proc
+      end
+
+      def field
+        @field ||= begin
+          ensure_defined
+          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
+          ensure_defined
+          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, "A unique identifier for the client performing the mutation."
+            type_fields.each do |name, field_obj|
+              field name, field: field_obj
+            end
+          end
+        end
+      end
+
+      def input_type
+        @input_type ||= begin
+          ensure_defined
+          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, "A unique identifier for the client performing the mutation."
+            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[:input][: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/page_info.rb

@@ -0,0 +1,13 @@
+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, "Indicates if there are more pages to fetch", property: :has_next_page
+      field :hasPreviousPage, !types.Boolean, "Indicates if there are any pages prior to the current page", property: :has_previous_page
+      field :startCursor, types.String, "When paginating backwards, the cursor to continue", property: :start_cursor
+      field :endCursor, types.String, "When paginating forwards, the cursor to continue", property: :end_cursor
+    end
+  end
+end

data/lib/graphql/relay/relation_connection.rb

@@ -0,0 +1,98 @@
+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
+        Base64.strict_encode64(offset.to_s)
+      end
+
+      def has_next_page
+        !!(first && sliced_nodes.limit(limit + 1).count > limit)
+      end
+
+      def has_previous_page
+        !!(last && starting_offset > 0)
+      end
+
+      private
+
+      # apply first / last limit results
+      def paged_nodes
+        @paged_nodes ||= begin
+          items = sliced_nodes
+          items.limit(limit)
+        end
+      end
+
+      # Apply cursors to edges
+      def sliced_nodes
+        @sliced_nodes ||= begin
+          items = object
+          items.offset(starting_offset)
+        end
+      end
+
+      def offset_from_cursor(cursor)
+        Base64.decode64(cursor).to_i
+      end
+
+      def starting_offset
+        @starting_offset ||= begin
+          if before
+            [previous_offset, 0].max
+          else
+            previous_offset
+          end
+        end
+      end
+
+      # Offset from the previous selection, if there was one
+      # Otherwise, zero
+      def previous_offset
+        @previous_offset ||= if after
+          offset_from_cursor(after)
+        elsif before
+          prev_page_size = [max_page_size, last].compact.min || 0
+          offset_from_cursor(before) - prev_page_size - 1
+        else
+          0
+        end
+      end
+
+      # Limit to apply to this query:
+      # - find a value from the query
+      # - don't exceed max_page_size
+      # - otherwise, don't limit
+      def limit
+        @limit ||= begin
+          limit_from_arguments = if first
+            first
+          else
+            if previous_offset < 0
+              previous_offset + (last ? last : 0)
+            else
+              last
+            end
+          end
+          [limit_from_arguments, max_page_size].compact.min
+        end
+      end
+
+      def paged_nodes_array
+        @paged_nodes_array ||= paged_nodes.to_a
+      end
+    end
+
+
+    if defined?(ActiveRecord::Relation)
+      BaseConnection.register_connection_implementation(ActiveRecord::Relation, RelationConnection)
+    end
+    if defined?(Sequel::Dataset)
+      BaseConnection.register_connection_implementation(Sequel::Dataset, RelationConnection)
+    end
+  end
+end