graphql 1.9.21 → 2.0.0

data/lib/graphql/relay/mutation.rb

@@ -1,190 +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
-    # 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"
-    #    #   }
-    #    # }}
-    #
-    # @example Using a GraphQL::Function
-    #   class UpdateAttributes < GraphQL::Function
-    #     attr_reader :model, :return_as, :arguments
-    #
-    #     def initialize(model:, return_as:, attributes:)
-    #       @model = model
-    #       @arguments = {}
-    #       attributes.each do |name, type|
-    #         arg_name = name.to_s
-    #         @arguments[arg_name] = GraphQL::Argument.define(name: arg_name, type: type)
-    #       end
-    #       @arguments["id"] = GraphQL::Argument.define(name: "id", type: !GraphQL::ID_TYPE)
-    #       @return_as = return_as
-    #       @attributes = attributes
-    #     end
-    #
-    #     def type
-    #       fn = self
-    #       GraphQL::ObjectType.define do
-    #         name "Update#{fn.model.name}AttributesResponse"
-    #         field :clientMutationId, types.ID
-    #         field fn.return_as.keys[0], fn.return_as.values[0]
-    #       end
-    #     end
-    #
-    #     def call(obj, args, ctx)
-    #       record = @model.find(args[:inputs][:id])
-    #       new_values = {}
-    #       @attributes.each { |a| new_values[a] = args[a] }
-    #       record.update(new_values)
-    #       { @return_as => record }
-    #     end
-    #   end
-    #
-    #   UpdateNameMutation = GraphQL::Relay::Mutation.define do
-    #     name "UpdateName"
-    #     function UpdateAttributes.new(model: Item, return_as: { item: ItemType }, attributes: {name: !types.String})
-    #   end
-
-    class Mutation
-      include GraphQL::Define::InstanceDefinable
-      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
-        @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,36 +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)
-        # 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)
-        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
-        @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
-  end
-end

data/lib/graphql/relay/relation_connection.rb

@@ -1,190 +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
-        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
-
-      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,30 +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::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::Relay::EdgeType.create_type(self, **kwargs, &block)
-      end
-    end
-  end
-end

data/lib/graphql/scalar_type.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # # GraphQL::ScalarType
-  #
-  # Scalars are plain values. They are leaf nodes in a GraphQL query tree.
-  #
-  # ## Built-in Scalars
-  #
-  # `GraphQL` comes with standard built-in scalars:
-  #
-  # |Constant | `.define` helper|
-  # |-------|--------|
-  # |`GraphQL::STRING_TYPE` | `types.String`|
-  # |`GraphQL::INT_TYPE` | `types.Int`|
-  # |`GraphQL::FLOAT_TYPE` | `types.Float`|
-  # |`GraphQL::ID_TYPE` | `types.ID`|
-  # |`GraphQL::BOOLEAN_TYPE` | `types.Boolean`|
-  #
-  # (`types` is an instance of `GraphQL::Definition::TypeDefiner`; `.String`, `.Float`, etc are methods which return built-in scalars.)
-  #
-  # ## Custom Scalars
-  #
-  # You can define custom scalars for your GraphQL server. It requires some special functions:
-  #
-  # - `coerce_input` is used to prepare incoming values for GraphQL execution. (Incoming values come from variables or literal values in the query string.)
-  # - `coerce_result` is used to turn Ruby values _back_ into serializable values for query responses.
-  #
-  # @example defining a type for Time
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) { Time.at(Float(value)) }
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  #
-  # You can customize the error message for invalid input values by raising a `GraphQL::CoercionError` within `coerce_input`:
-  #
-  # @example raising a custom error message
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) do
-  #       begin
-  #         Time.at(Float(value))
-  #       rescue ArgumentError
-  #         raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to Float"
-  #       end
-  #     end
-  #
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  # This will result in the message of the `GraphQL::CoercionError` being used in the error response:
-  #
-  # @example custom error response
-  #   {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
-  #
-  class ScalarType < GraphQL::BaseType
-    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
-      if value.is_a?(GraphQL::Language::Nodes::Enum) || coerce_non_null_input(value, ctx).nil?
-        result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{name}")
-      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,15 +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
-        end
-      end
-    end
-  end
-end