graphql 1.12.12 → 2.4.8

data/lib/graphql/query/serial_execution/operation_resolution.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    class SerialExecution
-      module OperationResolution
-        def self.resolve(selection, target, query)
-          result = query.context.execution_strategy.selection_resolution.resolve(
-            query.root_value,
-            target,
-            selection,
-            query.context,
-          )
-
-          result
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    class SerialExecution
-      module SelectionResolution
-        def self.resolve(target, current_type, selection, query_ctx)
-          selection_result = {}
-
-          selection.typed_children[current_type].each do |name, subselection|
-            selection_result.merge!(query_ctx.execution_strategy.field_resolution.new(
-              subselection,
-              current_type,
-              target,
-              query_ctx
-            ).result)
-          end
-
-          selection_result
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    class SerialExecution
-      module ValueResolution
-        def self.resolve(parent_type, field_defn, field_type, value, selection, query_ctx)
-          if value.nil? || value.is_a?(GraphQL::ExecutionError)
-            if field_type.kind.non_null?
-              if value.nil?
-                type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
-                query_ctx.schema.type_error(type_error, query_ctx)
-              end
-              raise GraphQL::Query::Executor::PropagateNull
-            else
-              nil
-            end
-          else
-            case field_type.kind
-            when GraphQL::TypeKinds::SCALAR, GraphQL::TypeKinds::ENUM
-              field_type.coerce_result(value, query_ctx)
-            when GraphQL::TypeKinds::LIST
-              wrapped_type = field_type.of_type
-              result = []
-              i = 0
-              value.each do |inner_value|
-                inner_ctx = query_ctx.spawn_child(
-                  key: i,
-                  object: inner_value,
-                  irep_node: selection,
-                )
-
-                result << resolve(
-                  parent_type,
-                  field_defn,
-                  wrapped_type,
-                  inner_value,
-                  selection,
-                  inner_ctx,
-                )
-                i += 1
-              end
-              result
-            when GraphQL::TypeKinds::NON_NULL
-              wrapped_type = field_type.of_type
-              resolve(
-                parent_type,
-                field_defn,
-                wrapped_type,
-                value,
-                selection,
-                query_ctx,
-              )
-            when GraphQL::TypeKinds::OBJECT
-              query_ctx.execution_strategy.selection_resolution.resolve(
-                value,
-                field_type,
-                selection,
-                query_ctx
-              )
-            when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
-              query = query_ctx.query
-              resolved_type = query.resolve_type(value)
-              possible_types = query.possible_types(field_type)
-
-              if !possible_types.include?(resolved_type)
-                type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
-                query.schema.type_error(type_error, query_ctx)
-                raise GraphQL::Query::Executor::PropagateNull
-              else
-                resolve(
-                  parent_type,
-                  field_defn,
-                  resolved_type,
-                  value,
-                  selection,
-                  query_ctx,
-                )
-              end
-            else
-              raise("Unknown type kind: #{field_type.kind}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-require "graphql/query/serial_execution/value_resolution"
-require "graphql/query/serial_execution/field_resolution"
-require "graphql/query/serial_execution/operation_resolution"
-require "graphql/query/serial_execution/selection_resolution"
-
-module GraphQL
-  class Query
-    class SerialExecution
-      # This is the only required method for an Execution strategy.
-      # You could create a custom execution strategy and configure your schema to
-      # use that custom strategy instead.
-      #
-      # @param ast_operation [GraphQL::Language::Nodes::OperationDefinition] The operation definition to run
-      # @param root_type [GraphQL::ObjectType] either the query type or the mutation type
-      # @param query_object [GraphQL::Query] the query object for this execution
-      # @return [Hash] a spec-compliant GraphQL result, as a hash
-      def execute(ast_operation, root_type, query_object)
-        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
-        operation_resolution.resolve(
-          query_object.irep_selection,
-          root_type,
-          query_object
-        )
-      end
-
-      def field_resolution
-        self.class::FieldResolution
-      end
-
-      def operation_resolution
-        self.class::OperationResolution
-      end
-
-      def selection_resolution
-        self.class::SelectionResolution
-      end
-    end
-  end
-end

data/lib/graphql/relay/array_connection.rb

@@ -1,83 +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
-
-      def first
-        @first ||= begin
-          capped = limit_pagination_argument(arguments[:first], max_page_size)
-          if capped.nil? && last.nil?
-            capped = max_page_size
-          end
-          capped
-        end
-      end
-
-      def last
-        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
-      end
-
-      private
-
-      # 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,189 +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)
-        GraphQL::Deprecation.warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
-
-        deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
-        if deprecated_caller
-          GraphQL::Deprecation.warn "  -> called from #{deprecated_caller}"
-        end
-
-        @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)
-      end
-
-      # The value passed as `first:`, if there was one. Negative numbers become `0`.
-      # @return [Integer, nil]
-      def first
-        @first ||= begin
-          capped = limit_pagination_argument(arguments[:first], max_page_size)
-          if capped.nil? && last.nil?
-            capped = max_page_size
-          end
-          capped
-        end
-      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 ||= limit_pagination_argument(arguments[:last], max_page_size)
-      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
-
-      # @param argument [nil, Integer] `first` or `last`, as provided by the client
-      # @param max_page_size [nil, Integer]
-      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
-      def limit_pagination_argument(argument, max_page_size)
-        if argument
-          if argument < 0
-            argument = 0
-          elsif max_page_size && argument > max_page_size
-            argument = max_page_size
-          end
-        end
-        argument
-      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::DEPRECATED_INT_TYPE, "Returns the first _n_ elements from the list."],
-              ["after", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
-              ["last", GraphQL::DEPRECATED_INT_TYPE, "Returns the last _n_ elements from the list."],
-              ["before", GraphQL::DEPRECATED_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.deprecated_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