graphql 1.9.5 → 1.13.19

data/lib/graphql/relay/mutation.rb

@@ -5,95 +5,10 @@ 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
-
+    # @api deprecated
     class Mutation
       include GraphQL::Define::InstanceDefinable
-      accepts_definitions(
+      deprecated_accepts_definitions(
         :name, :description, :resolve,
         :return_type,
         :return_interfaces,
@@ -115,6 +30,7 @@ module GraphQL
       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

data/lib/graphql/relay/node.rb

@@ -5,23 +5,25 @@ module GraphQL
     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)
+          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)
+          field = field.redefine(**kwargs, &block)
         end
 
         field
@@ -29,6 +31,7 @@ module GraphQL
 
       # @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

data/lib/graphql/relay/page_info.rb

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

data/lib/graphql/relay/range_add.rb

@@ -9,7 +9,7 @@ module GraphQL
     # should be ordered and paginated before providing it here.
     #
     # @example Adding a comment to list of comments
-    #   post = Post.find(args[:postId])
+    #   post = Post.find(args[:post_id])
     #   comments = post.comments
     #   new_comment = comments.build(body: args[:body])
     #   new_comment.save!
@@ -18,13 +18,13 @@ module GraphQL
     #     parent: post,
     #     collection: comments,
     #     item: new_comment,
-    #     context: ctx,
+    #     context: context,
     #   )
     #
     #   response = {
     #     post: post,
-    #     commentsConnection: range_add.connection,
-    #     newCommentEdge: range_add.edge,
+    #     comments_connection: range_add.connection,
+    #     new_comment_edge: range_add.edge,
     #   }
     class RangeAdd
       attr_reader :edge, :connection, :parent
@@ -33,12 +33,30 @@ module GraphQL
       # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
       # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
       # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
-      # @param edge_class [Class] The class to wrap `item` with
-      def initialize(collection:, item:, parent: nil, context: nil, edge_class: Relay::Edge)
-        connection_class = BaseConnection.connection_for_nodes(collection)
+      # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
+      def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
+        if context.nil?
+          caller_loc = caller(2, 1).first
+          GraphQL::Deprecation.warn("`context: ...` will be required by `RangeAdd.new` in GraphQL-Ruby 2.0. Add `context: context` to the call at #{caller_loc}.")
+        end
+        if context && context.schema.new_connections?
+          conn_class = context.schema.connections.wrapper_for(collection)
+          # The rest will be added by ConnectionExtension
+          @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
+          # Check if this connection supports it, to support old versions of GraphQL-Pro
+          @edge = if @connection.respond_to?(:range_add_edge)
+            @connection.range_add_edge(item)
+          else
+            @connection.edge_class.new(item, @connection)
+          end
+        else
+          connection_class = BaseConnection.connection_for_nodes(collection)
+          @connection = connection_class.new(collection, {}, parent: parent, context: context)
+          edge_class ||= Relay::Edge
+          @edge = edge_class.new(item, @connection)
+        end
+
         @parent = parent
-        @connection = connection_class.new(collection, {}, parent: parent, context: context)
-        @edge = edge_class.new(item, @connection)
       end
     end
   end

data/lib/graphql/relay/relation_connection.rb

@@ -25,12 +25,16 @@ module GraphQL
 
       def has_next_page
         if first
-          paged_nodes.length >= first && sliced_nodes_count > first
-        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
-          sliced_nodes_count >= last
-        else
-          false
+          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
@@ -46,19 +50,17 @@ module GraphQL
       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
+        @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
-        return @last if defined? @last
-
-        @last = get_limited_arg(:last)
-        @last = max_page_size if @last && max_page_size && @last > max_page_size
-        @last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       private

data/lib/graphql/relay/type_extensions.rb

@@ -12,6 +12,7 @@ module GraphQL
       # 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
 
@@ -23,6 +24,7 @@ module GraphQL
       # 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

data/lib/graphql/rubocop/graphql/base_cop.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "rubocop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      class BaseCop < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        # Return the source of `send_node`, but without the keyword argument represented by `pair_node`
+        def source_without_keyword_argument(send_node, pair_node)
+          # work back to the preceeding comma
+          first_pos = pair_node.location.expression.begin_pos
+          end_pos = pair_node.location.expression.end_pos
+          node_source = send_node.source_range.source
+          node_first_pos = send_node.location.expression.begin_pos
+
+          relative_first_pos = first_pos - node_first_pos
+          relative_last_pos = end_pos - node_first_pos
+
+          begin_removal_pos = relative_first_pos
+          while node_source[begin_removal_pos] != ","
+            begin_removal_pos -= 1
+            if begin_removal_pos < 1
+              raise "Invariant: somehow backtracked to beginning of node looking for a comma (node source: #{node_source.inspect})"
+            end
+          end
+
+          end_removal_pos = relative_last_pos
+          cleaned_node_source = node_source[0...begin_removal_pos] + node_source[end_removal_pos..-1]
+          cleaned_node_source
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop/graphql/default_null_true.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any field configuration which duplicates
+      # the default `null: true` property.
+      #
+      # `null: true` is default because nullable fields can always be converted
+      # to non-null fields (`null: false`) without a breaking change. (The opposite change, from `null: false`
+      # to `null: true`, change.)
+      #
+      # @example
+      #   # Both of these define `name: String` in GraphQL:
+      #
+      #   # bad
+      #   field :name, String, null: true
+      #
+      #   # good
+      #   field :name, String
+      #
+      class DefaultNullTrue < BaseCop
+        MSG = "`null: true` is the default and can be removed."
+
+        def_node_matcher :field_config_with_null_true?, <<-Pattern
+        (
+          send nil? :field ... (hash $(pair (sym :null) (true)) ...)
+        )
+        Pattern
+
+        def on_send(node)
+          field_config_with_null_true?(node) do |null_config|
+            add_offense(null_config) do |corrector|
+              cleaned_node_source = source_without_keyword_argument(node, null_config)
+              corrector.replace(node.source_range, cleaned_node_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop/graphql/default_required_true.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "./base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any argument configuration which duplicates
+      # the default `required: true` property.
+      #
+      # `required: true` is default because required arguments can always be converted
+      # to optional arguments (`required: false`) without a breaking change. (The opposite change, from `required: false`
+      # to `required: true`, change.)
+      #
+      # @example
+      #   # Both of these define `id: ID!` in GraphQL:
+      #
+      #   # bad
+      #   argument :id, ID, required: true
+      #
+      #   # good
+      #   argument :id, ID
+      #
+      class DefaultRequiredTrue < BaseCop
+        MSG = "`required: true` is the default and can be removed."
+
+        def_node_matcher :argument_config_with_required_true?, <<-Pattern
+        (
+          send {nil? _} :argument ... (hash <$(pair (sym :required) (true)) ...>)
+        )
+        Pattern
+
+        def on_send(node)
+          argument_config_with_required_true?(node) do |required_config|
+            add_offense(required_config) do |corrector|
+              cleaned_node_source = source_without_keyword_argument(node, required_config)
+              corrector.replace(node, cleaned_node_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "graphql/rubocop/graphql/default_null_true"
+require "graphql/rubocop/graphql/default_required_true"

data/lib/graphql/scalar_type.rb

@@ -1,65 +1,10 @@
 # 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"]}
-  #
+  # @api deprecated
   class ScalarType < GraphQL::BaseType
-    accepts_definitions :coerce, :coerce_input, :coerce_result
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    deprecated_accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result
 
     module NoOpCoerce
@@ -117,8 +62,6 @@ module GraphQL
         value.to_h
       elsif value.is_a?(Array)
         value.map { |element| raw_coercion_input(element) }
-      elsif value.is_a?(GraphQL::Language::Nodes::Enum)
-        value.name
       else
         value
       end
@@ -126,8 +69,21 @@ module GraphQL
 
     def validate_non_null_input(value, ctx)
       result = Query::InputValidationResult.new
-      if coerce_non_null_input(value, ctx).nil?
+
+      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