graphql 1.10.2 → 2.0.21

data/lib/graphql/relay/array_connection.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    class ArrayConnection < BaseConnection
-      def cursor_from_node(item)
-        idx = (after ? index_from_cursor(after) : 0) + sliced_nodes.find_index(item) + 1
-        encode(idx.to_s)
-      end
-
-      def has_next_page
-        if first
-          # There are more items after these items
-          sliced_nodes.count > first
-        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && before
-          # The original array is longer than the `before` index
-          index_from_cursor(before) < nodes.length + 1
-        else
-          false
-        end
-      end
-
-      def has_previous_page
-        if last
-          # There are items preceding the ones in this result
-          sliced_nodes.count > last
-        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && after
-          # We've paginated into the Array a bit, there are some behind us
-          index_from_cursor(after) > 0
-        else
-          false
-        end
-      end
-
-      private
-
-      def first
-        return @first if defined? @first
-
-        @first = get_limited_arg(:first)
-        @first = max_page_size if @first && max_page_size && @first > max_page_size
-        @first
-      end
-
-      def last
-        return @last if defined? @last
-
-        @last = get_limited_arg(:last)
-        @last = max_page_size if @last && max_page_size && @last > max_page_size
-        @last
-      end
-
-      # apply first / last limit results
-      def paged_nodes
-        @paged_nodes ||= begin
-          items = sliced_nodes
-
-          items = items.first(first) if first
-          items = items.last(last) if last
-          items = items.first(max_page_size) if max_page_size && !first && !last
-
-          items
-        end
-      end
-
-      # Apply cursors to edges
-      def sliced_nodes
-        @sliced_nodes ||= if before && after
-          nodes[index_from_cursor(after)..index_from_cursor(before)-1] || []
-        elsif before
-          nodes[0..index_from_cursor(before)-2] || []
-        elsif after
-          nodes[index_from_cursor(after)..-1] || []
-        else
-          nodes
-        end
-      end
-
-      def index_from_cursor(cursor)
-        decode(cursor).to_i
-      end
-    end
-
-    BaseConnection.register_connection_implementation(Array, ArrayConnection)
-  end
-end

data/lib/graphql/relay/base_connection.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # Subclasses must implement:
-    #   - {#cursor_from_node}, which returns an opaque cursor for the given item
-    #   - {#sliced_nodes}, which slices by `before` & `after`
-    #   - {#paged_nodes}, which applies `first` & `last` limits
-    #
-    # In a subclass, you have access to
-    #   - {#nodes}, the collection which the connection will wrap
-    #   - {#first}, {#after}, {#last}, {#before} (arguments passed to the field)
-    #   - {#max_page_size} (the specified maximum page size that can be returned from a connection)
-    #
-    class BaseConnection
-      # Just to encode data in the cursor, use something that won't conflict
-      CURSOR_SEPARATOR = "---"
-
-      # Map of collection class names -> connection_classes
-      # eg `{"Array" => ArrayConnection}`
-      CONNECTION_IMPLEMENTATIONS = {}
-
-      class << self
-        # Find a connection implementation suitable for exposing `nodes`
-        #
-        # @param nodes [Object] A collection of nodes (eg, Array, AR::Relation)
-        # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
-        def connection_for_nodes(nodes)
-          # If it's a new-style connection object, it's already ready to go
-          if nodes.is_a?(GraphQL::Pagination::Connection)
-            return nodes
-          end
-          # Check for class _names_ because classes can be redefined in Rails development
-          nodes.class.ancestors.each do |ancestor|
-            conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
-            if conn_impl
-              return conn_impl
-            end
-          end
-          # Should have found a connection during the loop:
-          raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
-        end
-
-        # Add `connection_class` as the connection wrapper for `nodes_class`
-        # eg, `RelationConnection` is the implementation for `AR::Relation`
-        # @param nodes_class [Class] A class representing a collection (eg, Array, AR::Relation)
-        # @param connection_class [Class] A class implementing Connection methods
-        def register_connection_implementation(nodes_class, connection_class)
-          CONNECTION_IMPLEMENTATIONS[nodes_class.name] = connection_class
-        end
-      end
-
-      attr_reader :nodes, :arguments, :max_page_size, :parent, :field, :context
-
-      # Make a connection, wrapping `nodes`
-      # @param nodes [Object] The collection of nodes
-      # @param arguments [GraphQL::Query::Arguments] Query arguments
-      # @param field [GraphQL::Field] The underlying field
-      # @param max_page_size [Int] The maximum number of results to return
-      # @param parent [Object] The object which this collection belongs to
-      # @param context [GraphQL::Query::Context] The context from the field being resolved
-      def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
-        @context = context
-        @nodes = nodes
-        @arguments = arguments
-        @field = field
-        @parent = parent
-        @encoder = context ? @context.schema.cursor_encoder : GraphQL::Schema::Base64Encoder
-        @max_page_size = max_page_size.nil? && context ? @context.schema.default_max_page_size : max_page_size
-      end
-
-      def encode(data)
-        @encoder.encode(data, nonce: true)
-      end
-
-      def decode(data)
-        @encoder.decode(data, nonce: true)
-      rescue ArgumentError
-        raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
-      end
-
-      # The value passed as `first:`, if there was one. Negative numbers become `0`.
-      # @return [Integer, nil]
-      def first
-        @first ||= get_limited_arg(:first)
-      end
-
-      # The value passed as `after:`, if there was one
-      # @return [String, nil]
-      def after
-        arguments[:after]
-      end
-
-      # The value passed as `last:`, if there was one. Negative numbers become `0`.
-      # @return [Integer, nil]
-      def last
-        @last ||= get_limited_arg(:last)
-      end
-
-      # The value passed as `before:`, if there was one
-      # @return [String, nil]
-      def before
-        arguments[:before]
-      end
-
-      # These are the nodes to render for this connection,
-      # probably wrapped by {GraphQL::Relay::Edge}
-      def edge_nodes
-        @edge_nodes ||= paged_nodes
-      end
-
-      # Support the `pageInfo` field
-      def page_info
-        self
-      end
-
-      # Used by `pageInfo`
-      def has_next_page
-        !!(first && sliced_nodes.count > first)
-      end
-
-      # Used by `pageInfo`
-      def has_previous_page
-        !!(last && sliced_nodes.count > last)
-      end
-
-      # Used by `pageInfo`
-      def start_cursor
-        if start_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).first
-          return cursor_from_node(start_node)
-        else
-          return nil
-        end
-      end
-
-      # Used by `pageInfo`
-      def end_cursor
-        if end_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).last
-          return cursor_from_node(end_node)
-        else
-          return nil
-        end
-      end
-
-      # An opaque operation which returns a connection-specific cursor.
-      def cursor_from_node(object)
-        raise GraphQL::RequiredImplementationMissingError, "must return a cursor for this object/connection pair"
-      end
-
-      def inspect
-        "#<GraphQL::Relay::Connection @parent=#{@parent.inspect} @arguments=#{@arguments.to_h.inspect}>"
-      end
-
-      private
-
-      # Return a sanitized `arguments[arg_name]` (don't allow negatives)
-      def get_limited_arg(arg_name)
-        arg_value = arguments[arg_name]
-        if arg_value.nil?
-          arg_value
-        elsif arg_value < 0
-          0
-        else
-          arg_value
-        end
-      end
-
-      def paged_nodes
-        raise GraphQL::RequiredImplementationMissingError, "must return nodes for this connection after paging"
-      end
-
-      def sliced_nodes
-        raise GraphQL::RequiredImplementationMissingError, "must return  all nodes for this connection after chopping off first and last"
-      end
-    end
-  end
-end

data/lib/graphql/relay/connection_instrumentation.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # Provided a GraphQL field which returns a collection of nodes,
-    # wrap that field to expose those nodes as a connection.
-    #
-    # The original resolve proc is used to fetch nodes,
-    # then a connection implementation is fetched with {BaseConnection.connection_for_nodes}.
-    module ConnectionInstrumentation
-      def self.default_arguments
-        @default_arguments ||= begin
-          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 cursor."],
-              ["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 cursor."],
-            ]
-
-          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
-        end
-      end
-
-      # Build a connection field from a {GraphQL::Field} by:
-      # - Merging in the default arguments
-      # - Transforming its resolve function to return a connection object
-      def self.instrument(type, field)
-        # Don't apply the wrapper to class-based fields, since they
-        # use Schema::Field::ConnectionFilter
-        if field.connection? && !field.metadata[:type_class]
-          connection_arguments = default_arguments.merge(field.arguments)
-          original_resolve = field.resolve_proc
-          original_lazy_resolve = field.lazy_resolve_proc
-          connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve)
-          connection_lazy_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_lazy_resolve)
-          field.redefine(
-            resolve: connection_resolve,
-            lazy_resolve: connection_lazy_resolve,
-            arguments: connection_arguments,
-          )
-        else
-          field
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/connection_resolve.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    class ConnectionResolve
-      def initialize(field, underlying_resolve)
-        @field = field
-        @underlying_resolve = underlying_resolve
-        @max_page_size = field.connection_max_page_size
-      end
-
-      def call(obj, args, ctx)
-        # in a lazy resolve hook, obj is the promise,
-        # get the object that the promise was
-        # originally derived from
-        parent = ctx.object
-
-        nodes = @underlying_resolve.call(obj, args, ctx)
-
-        if nodes.nil? || ctx.schema.lazy?(nodes) || nodes.is_a?(GraphQL::Execution::Execute::Skip) || ctx.wrapped_connection
-          nodes
-        else
-          ctx.wrapped_connection = true
-          build_connection(nodes, args, parent, ctx)
-        end
-      end
-
-      private
-
-      def build_connection(nodes, args, parent, ctx)
-        if nodes.is_a? GraphQL::ExecutionError
-          ctx.add_error(nodes)
-          nil
-        else
-          if parent.is_a?(GraphQL::Schema::Object)
-            parent = parent.object
-          end
-          connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
-          connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/connection_type.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # @api deprecated
-    module ConnectionType
-      class << self
-        # @return [Boolean] If true, connection types get a `nodes` shortcut field
-        attr_accessor :default_nodes_field
-        # @return [Boolean] If true, connections check for reverse-direction `has*Page` values
-        attr_accessor :bidirectional_pagination
-      end
-
-      self.default_nodes_field = false
-      self.bidirectional_pagination = false
-
-      # @api deprecated
-      def self.create_type(wrapped_type, edge_type: nil, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
-        custom_edge_class = edge_class
-
-        # Any call that would trigger `wrapped_type.ensure_defined`
-        # must be inside this lazy block, otherwise we get weird
-        # cyclical dependency errors :S
-        ObjectType.define do
-          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
-          edge_type ||= wrapped_type.edge_type
-          name("#{type_name}Connection")
-          description("The connection type for #{type_name}.")
-          field :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :edge_nodes
-
-          if nodes_field
-            field :nodes, types[wrapped_type],  "A list of nodes.", property: :edge_nodes
-          end
-
-          field :pageInfo, !PageInfo, "Information to aid in pagination.", property: :page_info
-          relay_node_type(wrapped_type)
-          block && instance_eval(&block)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/edge.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # Mostly an internal concern.
-    #
-    # Wraps an object as a `node`, and exposes a connection-specific `cursor`.
-    class Edge
-      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
-
-      def inspect
-        "#<GraphQL::Relay::Edge (#{parent.inspect} => #{node.inspect})>"
-      end
-    end
-  end
-end

data/lib/graphql/relay/edge_type.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    module EdgeType
-      # @api deprecated
-      def self.create_type(wrapped_type, name: nil, &block)
-        GraphQL::ObjectType.define do
-          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
-          name("#{type_name}Edge")
-          description "An edge in a connection."
-          field :node, wrapped_type, "The item at the end of the edge."
-          field :cursor, !types.String, "A cursor for use in pagination."
-          relay_node_type(wrapped_type)
-          block && instance_eval(&block)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/edges_instrumentation.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    module EdgesInstrumentation
-      def self.instrument(type, field)
-        if field.edges?
-          edges_resolve = EdgesResolve.new(edge_class: field.edge_class, resolve: field.resolve_proc)
-          edges_lazy_resolve = EdgesResolve.new(edge_class: field.edge_class, resolve: field.lazy_resolve_proc)
-
-          field.redefine(
-            resolve: edges_resolve,
-            lazy_resolve: edges_lazy_resolve,
-          )
-        else
-          field
-        end
-      end
-
-
-      class EdgesResolve
-        def initialize(edge_class:, resolve:)
-          @edge_class = edge_class
-          @resolve_proc = resolve
-        end
-
-        # A user's custom Connection may return a lazy object,
-        # if so, handle it later.
-        def call(obj, args, ctx)
-          parent = ctx.object
-          nodes = @resolve_proc.call(obj, args, ctx)
-          if ctx.schema.lazy?(nodes)
-            nodes
-          else
-            nodes.map { |item| item.is_a?(GraphQL::Pagination::Connection::Edge) ? item : @edge_class.new(item, parent) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/global_id_resolve.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    class GlobalIdResolve
-      def initialize(type:)
-        @type = type
-      end
-
-      def call(obj, args, ctx)
-        if obj.is_a?(GraphQL::Schema::Object)
-          obj = obj.object
-        end
-        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition : @type
-        ctx.query.schema.id_from_object(obj, type, ctx)
-      end
-    end
-  end
-end

data/lib/graphql/relay/mongo_relation_connection.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # A connection implementation to expose MongoDB collection objects.
-    # It works for:
-    # - `Mongoid::Criteria`
-    class MongoRelationConnection < RelationConnection
-      private
-
-      def relation_offset(relation)
-        relation.options.skip
-      end
-
-      def relation_limit(relation)
-        relation.options.limit
-      end
-
-      def relation_count(relation)
-        # Must perform query (hence #to_a) to count results https://jira.mongodb.org/browse/MONGOID-2325
-        relation.to_a.count
-      end
-
-      def limit_nodes(sliced_nodes, limit)
-        if limit == 0
-          if sliced_nodes.respond_to?(:none) # added in Mongoid 4.0
-            sliced_nodes.without_options.none
-          else
-            sliced_nodes.where(id: nil) # trying to simulate #none for 3.1.7
-          end
-        else
-          sliced_nodes.limit(limit)
-        end
-      end
-    end
-
-    if defined?(Mongoid::Criteria)
-      BaseConnection.register_connection_implementation(Mongoid::Criteria, MongoRelationConnection)
-    end
-
-    # Mongoid 5 and 6
-    if defined?(Mongoid::Relations::Targets::Enumerable)
-      BaseConnection.register_connection_implementation(Mongoid::Relations::Targets::Enumerable, MongoRelationConnection)
-    end
-
-    # Mongoid 7
-    if defined?(Mongoid::Association::Referenced::HasMany::Targets::Enumerable)
-      BaseConnection.register_connection_implementation(Mongoid::Association::Referenced::HasMany::Targets::Enumerable, MongoRelationConnection)
-    end
-  end
-end

data/lib/graphql/relay/mutation/instrumentation.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    class Mutation
-      # @api private
-      module Instrumentation
-        # Modify mutation `return_field` resolves by wrapping the returned object
-        # in a {Mutation::Result}.
-        #
-        # By using an instrumention, we can apply our wrapper _last_,
-        # giving users access to the original resolve function in earlier instrumentation.
-        def self.instrument(type, field)
-          if field.mutation.is_a?(GraphQL::Relay::Mutation) || (field.mutation.is_a?(Class) && field.mutation < GraphQL::Schema::RelayClassicMutation)
-            new_resolve = Mutation::Resolve.new(field.mutation, field.resolve_proc)
-            field.redefine(resolve: new_resolve)
-          else
-            field
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/mutation/resolve.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    class Mutation
-      # Wrap a user-provided resolve function,
-      # wrapping the returned value in a {Mutation::Result}.
-      # Also, pass the `clientMutationId` to that result object.
-      # @api private
-      class Resolve
-        def initialize(mutation, resolve)
-          @mutation = mutation
-          @resolve = resolve
-          @wrap_result = mutation.is_a?(GraphQL::Relay::Mutation) && mutation.has_generated_return_type?
-          @class_based = mutation.is_a?(Class)
-        end
-
-        def call(obj, args, ctx)
-          mutation_result = begin
-            @resolve.call(obj, args[:input], ctx)
-          rescue GraphQL::ExecutionError => err
-            err
-          end
-
-          ctx.schema.after_lazy(mutation_result) do |res|
-            build_result(res, args, ctx)
-          end
-        end
-
-        private
-
-        def build_result(mutation_result, args, ctx)
-          if mutation_result.is_a?(GraphQL::ExecutionError)
-            ctx.add_error(mutation_result)
-            mutation_result = nil
-          end
-
-          if mutation_result.nil?
-            nil
-          elsif @wrap_result
-            if mutation_result && !mutation_result.is_a?(Hash)
-              raise StandardError, "Expected `#{mutation_result}` to be a Hash."\
-                " Return a hash when using `return_field` or specify a custom `return_type`."
-            end
-
-            @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
-          elsif @class_based
-            mutation_result[:client_mutation_id] = args[:input][:client_mutation_id]
-            mutation_result
-          else
-            mutation_result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/mutation/result.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    class Mutation
-      # Use this when the mutation's return type was generated from `return_field`s.
-      # It delegates field lookups to the hash returned from `resolve`.
-      # @api private
-      class Result
-        attr_reader :client_mutation_id
-        def initialize(client_mutation_id:, result:)
-          @client_mutation_id = client_mutation_id
-          result && result.each do |key, value|
-            self.public_send("#{key}=", value)
-          end
-        end
-
-        class << self
-          attr_accessor :mutation
-        end
-
-        # Build a subclass whose instances have a method
-        # for each of `mutation_defn`'s `return_field`s
-        # @param mutation_defn [GraphQL::Relay::Mutation]
-        # @return [Class]
-        def self.define_subclass(mutation_defn)
-          subclass = Class.new(self) do
-            mutation_result_methods = mutation_defn.return_type.all_fields.map do |f|
-              f.property || f.name
-            end
-            attr_accessor(*mutation_result_methods)
-            self.mutation = mutation_defn
-          end
-          subclass
-        end
-      end
-    end
-  end
-end