graphql 1.13.23 → 2.0.0

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

data/lib/graphql/relay/mutation.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-require "graphql/relay/mutation/instrumentation"
-require "graphql/relay/mutation/resolve"
-require "graphql/relay/mutation/result"
-
-module GraphQL
-  module Relay
-    # @api deprecated
-    class Mutation
-      include GraphQL::Define::InstanceDefinable
-      deprecated_accepts_definitions(
-        :name, :description, :resolve,
-        :return_type,
-        :return_interfaces,
-        input_field: GraphQL::Define::AssignArgument,
-        return_field: GraphQL::Define::AssignObjectField,
-        function: GraphQL::Define::AssignMutationFunction,
-      )
-      attr_accessor :name, :description, :fields, :arguments
-      attr_writer :return_type, :return_interfaces
-
-      ensure_defined(
-        :input_fields, :return_fields, :name, :description,
-        :fields, :arguments, :return_type,
-        :return_interfaces, :resolve=,
-        :field, :result_class, :input_type
-      )
-      # For backwards compat, but do we need this separate API?
-      alias :return_fields :fields
-      alias :input_fields :arguments
-
-      def initialize
-        GraphQL::Deprecation.warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
-        @fields = {}
-        @arguments = {}
-        @has_generated_return_type = false
-      end
-
-      def has_generated_return_type?
-        # Trigger the generation of the return type, if it is dynamically generated:
-        return_type
-        @has_generated_return_type
-      end
-
-      def resolve=(new_resolve_proc)
-        @resolve_proc = new_resolve_proc
-      end
-
-      def field
-        @field ||= begin
-          relay_mutation = self
-          field_resolve_proc = @resolve_proc
-          GraphQL::Field.define do
-            type(relay_mutation.return_type)
-            description(relay_mutation.description)
-            argument :input, !relay_mutation.input_type
-            resolve(field_resolve_proc)
-            mutation(relay_mutation)
-          end
-        end
-      end
-
-      def return_interfaces
-        @return_interfaces ||= []
-      end
-
-      def return_type
-        @return_type ||= begin
-          @has_generated_return_type = true
-          relay_mutation = self
-          GraphQL::ObjectType.define do
-            name("#{relay_mutation.name}Payload")
-            description("Autogenerated return type of #{relay_mutation.name}")
-            field :clientMutationId, types.String, "A unique identifier for the client performing the mutation.", property: :client_mutation_id
-            interfaces relay_mutation.return_interfaces
-            relay_mutation.return_fields.each do |name, field_obj|
-              field name, field: field_obj
-            end
-            mutation(relay_mutation)
-          end
-        end
-      end
-
-      def input_type
-        @input_type ||= begin
-          relay_mutation = self
-          input_object_type = GraphQL::InputObjectType.define do
-            name("#{relay_mutation.name}Input")
-            description("Autogenerated input type of #{relay_mutation.name}")
-            input_field :clientMutationId, types.String, "A unique identifier for the client performing the mutation."
-            mutation(relay_mutation)
-          end
-          input_fields.each do |name, arg|
-            input_object_type.arguments[name] = arg
-          end
-
-          input_object_type
-        end
-      end
-
-      def result_class
-        @result_class ||= Result.define_subclass(self)
-      end
-    end
-  end
-end

data/lib/graphql/relay/node.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # Helpers for working with Relay-specific Node objects.
-    module Node
-      # @return [GraphQL::Field] a field for finding objects by their global ID.
-      def self.field(**kwargs, &block)
-        GraphQL::Deprecation.warn "GraphQL::Relay::Node.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodeField instead"
-        # We have to define it fresh each time because
-        # its name will be modified and its description
-        # _may_ be modified.
-        field = GraphQL::Types::Relay::NodeField.graphql_definition
-
-        if kwargs.any? || block
-          field = field.redefine(**kwargs, &block)
-        end
-
-        field
-      end
-
-      def self.plural_field(**kwargs, &block)
-        GraphQL::Deprecation.warn "GraphQL::Relay::Nodes.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodesField instead"
-        field = GraphQL::Types::Relay::NodesField.graphql_definition
-
-        if kwargs.any? || block
-          field = field.redefine(**kwargs, &block)
-        end
-
-        field
-      end
-
-      # @return [GraphQL::InterfaceType] The interface which all Relay types must implement
-      def self.interface
-        GraphQL::Deprecation.warn "GraphQL::Relay::Node.interface will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::Node instead"
-        @interface ||= GraphQL::Types::Relay::Node.graphql_definition
-      end
-    end
-  end
-end

data/lib/graphql/relay/page_info.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # Wrap a Connection and expose its page info
-    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition(silence_deprecation_warning: true)
-  end
-end

data/lib/graphql/relay/relation_connection.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-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)
-        item_index = paged_nodes.index(item)
-        if item_index.nil?
-          raise("Can't generate cursor, item not found in connection: #{item}")
-        else
-          offset = item_index + 1 + ((paged_nodes_offset || 0) - (relation_offset(sliced_nodes) || 0))
-
-          if after
-            offset += offset_from_cursor(after)
-          elsif before
-            offset += offset_from_cursor(before) - 1 - sliced_nodes_count
-          end
-
-          encode(offset.to_s)
-        end
-      end
-
-      def has_next_page
-        if first
-          if defined?(ActiveRecord::Relation) && nodes.is_a?(ActiveRecord::Relation)
-            initial_offset = after ? offset_from_cursor(after) : 0
-            return paged_nodes.length >= first && nodes.offset(first + initial_offset).exists?
-          end
-          return paged_nodes.length >= first && sliced_nodes_count > first
-        end
-        if GraphQL::Relay::ConnectionType.bidirectional_pagination && last
-          return sliced_nodes_count >= last
-        end
-        false
-      end
-
-      def has_previous_page
-        if last
-          paged_nodes.length >= last && sliced_nodes_count > last
-        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && after
-          # We've already paginated through the collection a bit,
-          # there are nodes behind us
-          offset_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
-      # @return [Array]
-      def paged_nodes
-        return @paged_nodes if defined? @paged_nodes
-
-        items = sliced_nodes
-
-        if first
-          if relation_limit(items).nil? || relation_limit(items) > first
-            items = items.limit(first)
-          end
-        end
-
-        if last
-          if relation_limit(items)
-            if last <= relation_limit(items)
-              offset = (relation_offset(items) || 0) + (relation_limit(items) - last)
-              items = items.offset(offset).limit(last)
-            end
-          else
-            slice_count = relation_count(items)
-            offset = (relation_offset(items) || 0) + slice_count - [last, slice_count].min
-            items = items.offset(offset).limit(last)
-          end
-        end
-
-        if max_page_size && !first && !last
-          if relation_limit(items).nil? || relation_limit(items) > max_page_size
-            items = items.limit(max_page_size)
-          end
-        end
-
-        # Store this here so we can convert the relation to an Array
-        # (this avoids an extra DB call on Sequel)
-        @paged_nodes_offset = relation_offset(items)
-        @paged_nodes = items.to_a
-      end
-
-      def paged_nodes_offset
-        paged_nodes && @paged_nodes_offset
-      end
-
-      def relation_offset(relation)
-        if relation.respond_to?(:offset_value)
-          relation.offset_value
-        else
-          relation.opts[:offset]
-        end
-      end
-
-      def relation_limit(relation)
-        if relation.respond_to?(:limit_value)
-          relation.limit_value
-        else
-          relation.opts[:limit]
-        end
-      end
-
-      # If a relation contains a `.group` clause, a `.count` will return a Hash.
-      def relation_count(relation)
-        count_or_hash = if(defined?(ActiveRecord::Relation) && relation.is_a?(ActiveRecord::Relation))
-          relation.respond_to?(:unscope)? relation.unscope(:order).count(:all) : relation.count(:all)
-        else # eg, Sequel::Dataset, don't mess up others
-          relation.count
-        end
-        count_or_hash.is_a?(Integer) ? count_or_hash : count_or_hash.length
-      end
-
-      # Apply cursors to edges
-      def sliced_nodes
-        return @sliced_nodes if defined? @sliced_nodes
-
-        @sliced_nodes = nodes
-
-        if after
-          offset = (relation_offset(@sliced_nodes) || 0) + offset_from_cursor(after)
-          @sliced_nodes = @sliced_nodes.offset(offset)
-        end
-
-        if before && after
-          if offset_from_cursor(after) < offset_from_cursor(before)
-            @sliced_nodes = limit_nodes(@sliced_nodes,  offset_from_cursor(before) - offset_from_cursor(after) - 1)
-          else
-            @sliced_nodes = limit_nodes(@sliced_nodes, 0)
-          end
-
-        elsif before
-          @sliced_nodes = limit_nodes(@sliced_nodes, offset_from_cursor(before) - 1)
-        end
-
-        @sliced_nodes
-      end
-
-      def limit_nodes(sliced_nodes, limit)
-        if limit > 0 || defined?(ActiveRecord::Relation) && sliced_nodes.is_a?(ActiveRecord::Relation)
-          sliced_nodes.limit(limit)
-        else
-          sliced_nodes.where(false)
-        end
-      end
-
-      def sliced_nodes_count
-        return @sliced_nodes_count if defined? @sliced_nodes_count
-
-        # If a relation contains a `.group` clause, a `.count` will return a Hash.
-        @sliced_nodes_count = relation_count(sliced_nodes)
-      end
-
-      def offset_from_cursor(cursor)
-        decode(cursor).to_i
-      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

data/lib/graphql/relay/type_extensions.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Relay
-    # Mixin for Relay-related methods in type objects
-    # (used by BaseType and Schema::Member).
-    module TypeExtensions
-      # @return [GraphQL::ObjectType] The default connection type for this object type
-      def connection_type
-        @connection_type ||= define_connection
-      end
-
-      # Define a custom connection type for this object type
-      # @return [GraphQL::ObjectType]
-      def define_connection(**kwargs, &block)
-        GraphQL::Deprecation.warn ".connection_type and .define_connection will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
-        GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
-      end
-
-      # @return [GraphQL::ObjectType] The default edge type for this object type
-      def edge_type
-        @edge_type ||= define_edge
-      end
-
-      # Define a custom edge type for this object type
-      # @return [GraphQL::ObjectType]
-      def define_edge(**kwargs, &block)
-        GraphQL::Deprecation.warn ".edge_type and .define_edge will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
-        GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
-      end
-    end
-  end
-end

data/lib/graphql/scalar_type.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class ScalarType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    deprecated_accepts_definitions :coerce, :coerce_input, :coerce_result
-    ensure_defined :coerce_non_null_input, :coerce_result
-
-    module NoOpCoerce
-      def self.call(val, ctx)
-        val
-      end
-    end
-
-    def initialize
-      super
-      self.coerce = NoOpCoerce
-    end
-
-    def coerce=(proc)
-      self.coerce_input = proc
-      self.coerce_result = proc
-    end
-
-    def coerce_input=(coerce_input_fn)
-      if !coerce_input_fn.nil?
-        @coerce_input_proc = ensure_two_arg(coerce_input_fn, :coerce_input)
-      end
-    end
-
-    def coerce_result(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("coerce_isolated_result")
-        ctx = GraphQL::Query::NullContext
-      end
-      @coerce_result_proc.call(value, ctx)
-    end
-
-    def coerce_result=(coerce_result_fn)
-      if !coerce_result_fn.nil?
-        @coerce_result_proc = ensure_two_arg(coerce_result_fn, :coerce_result)
-      end
-    end
-
-    def kind
-      GraphQL::TypeKinds::SCALAR
-    end
-
-    private
-
-    def ensure_two_arg(callable, method_name)
-      GraphQL::BackwardsCompatibility.wrap_arity(callable, from: 1, to: 2, name: "#{name}.#{method_name}(val, ctx)")
-    end
-
-    def coerce_non_null_input(value, ctx)
-      @coerce_input_proc.call(raw_coercion_input(value), ctx)
-    end
-
-    def raw_coercion_input(value)
-      if value.is_a?(GraphQL::Language::Nodes::InputObject)
-        value.to_h
-      elsif value.is_a?(Array)
-        value.map { |element| raw_coercion_input(element) }
-      else
-        value
-      end
-    end
-
-    def validate_non_null_input(value, ctx)
-      result = Query::InputValidationResult.new
-
-      coerced_result = begin
-        coerce_non_null_input(value, ctx)
-      rescue GraphQL::CoercionError => err
-        err
-      end
-
-      if value.is_a?(GraphQL::Language::Nodes::Enum) || coerced_result.nil?
-        result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{name}")
-      elsif coerced_result.is_a?(GraphQL::CoercionError)
-        result.add_problem(
-          coerced_result.message,
-          message: coerced_result.message,
-          extensions: coerced_result.extensions
-        )
-      end
-      result
-    end
-  end
-end

data/lib/graphql/schema/catchall_middleware.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # In early GraphQL versions, errors would be "automatically"
-    # rescued and replaced with `"Internal error"`. That behavior
-    # was undesirable but this middleware is offered for people who
-    # want to preserve it.
-    #
-    # It has a couple of differences from the previous behavior:
-    #
-    # - Other parts of the query _will_ be run (previously,
-    #   execution would stop when the error was raised and the result
-    #   would have no `"data"` key at all)
-    # - The entry in {Query::Context#errors} is a {GraphQL::ExecutionError}, _not_
-    #   the originally-raised error.
-    # - The entry in the `"errors"` key includes the location of the field
-    #   which raised the errors.
-    #
-    # @example Use CatchallMiddleware with your schema
-    #     # All errors will be suppressed and replaced with "Internal error" messages
-    #     MySchema.middleware << GraphQL::Schema::CatchallMiddleware
-    #
-    module CatchallMiddleware
-      MESSAGE = "Internal error"
-
-      # Rescue any error and replace it with a {GraphQL::ExecutionError}
-      # whose message is {MESSAGE}
-      def self.call(parent_type, parent_object, field_definition, field_args, query_context)
-        yield
-      rescue StandardError
-        GraphQL::ExecutionError.new(MESSAGE)
-      end
-    end
-  end
-end

data/lib/graphql/schema/default_parse_error.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    module DefaultParseError
-      def self.call(parse_error, ctx)
-        ctx.errors.push(parse_error)
-      end
-    end
-  end
-end

data/lib/graphql/schema/default_type_error.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    module DefaultTypeError
-      def self.call(type_error, ctx)
-        case type_error
-        when GraphQL::InvalidNullError
-          ctx.errors << type_error
-        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
-          raise type_error
-        when GraphQL::IntegerDecodingError
-          nil
-        end
-      end
-    end
-  end
-end