graphql 1.8.0 → 1.12.12

data/lib/graphql/relay/node.rb

@@ -5,35 +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::Field.define do
-          type(GraphQL::Relay::Node.interface)
-          description("Fetches an object given its ID.")
-          argument(:id, !types.ID, "ID of the object.")
-          resolve(GraphQL::Relay::Node::FindNode)
-          relay_node_field(true)
-        end
+        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)
-        field = GraphQL::Field.define do
-          type(!types[GraphQL::Relay::Node.interface])
-          description("Fetches a list of objects given a list of IDs.")
-          argument(:ids, !types[!types.ID], "IDs of the objects.")
-          resolve(GraphQL::Relay::Node::FindNodes)
-          relay_nodes_field(true)
-        end
+        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
@@ -41,26 +31,8 @@ module GraphQL
 
       # @return [GraphQL::InterfaceType] The interface which all Relay types must implement
       def self.interface
-        @interface ||= GraphQL::InterfaceType.define do
-          name("Node")
-          description("An object with an ID.")
-          field(:id, !types.ID, "ID of the object.")
-          default_relay(true)
-        end
-      end
-
-      # A field resolve for finding objects by IDs
-      module FindNodes
-        def self.call(obj, args, ctx)
-          args[:ids].map { |id| ctx.query.schema.object_from_id(id, ctx) }
-        end
-      end
-
-      # A field resolve for finding an object by ID
-      module FindNode
-        def self.call(obj, args, ctx)
-          ctx.query.schema.object_from_id(args[:id], ctx )
-        end
+        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

data/lib/graphql/relay/page_info.rb

@@ -2,14 +2,6 @@
 module GraphQL
   module Relay
     # Wrap a Connection and expose its page info
-    PageInfo = GraphQL::ObjectType.define do
-      name("PageInfo")
-      description("Information about pagination in a connection.")
-      field :hasNextPage, !types.Boolean, "When paginating forwards, are there more items?", property: :has_next_page
-      field :hasPreviousPage, !types.Boolean, "When paginating backwards, are there more items?", property: :has_previous_page
-      field :startCursor, types.String, "When paginating backwards, the cursor to continue.", property: :start_cursor
-      field :endCursor, types.String, "When paginating forwards, the cursor to continue.", property: :end_cursor
-      default_relay true
-    end
+    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition
   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,26 @@ 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 && 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
@@ -124,7 +126,7 @@ module GraphQL
       # 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.count(:all)
+          relation.respond_to?(:unscope)? relation.unscope(:order).count(:all) : relation.count(:all)
         else # eg, Sequel::Dataset, don't mess up others
           relation.count
         end

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/relay.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'base64'
 
 require 'graphql/relay/page_info'
 require 'graphql/relay/edge'

data/lib/graphql/scalar_type.rb

@@ -1,64 +1,9 @@
 # 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
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result
 
@@ -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

data/lib/graphql/schema/addition.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Addition
+      attr_reader :directives, :possible_types, :types, :union_memberships, :references, :arguments_with_default_values
+
+      def initialize(schema:, own_types:, new_types:)
+        @schema = schema
+        @own_types = own_types
+        @directives = Set.new
+        @possible_types = {}
+        @types = {}
+        @union_memberships = {}
+        @references = Hash.new { |h, k| h[k] = [] }
+        @arguments_with_default_values = []
+        add_type_and_traverse(new_types)
+      end
+
+      private
+
+      def references_to(thing, from:)
+        @references[thing] << from
+      end
+
+      def get_type(name)
+        @types[name] || @schema.get_type(name)
+      end
+
+      # Lookup using `own_types` here because it's ok to override
+      # inherited types by name
+      def get_local_type(name)
+        @types[name] || @own_types[name]
+      end
+
+      def add_directives_from(owner)
+        dirs = owner.directives.map(&:class)
+        @directives.merge(dirs)
+        add_type_and_traverse(dirs)
+      end
+
+      def add_type_and_traverse(new_types)
+        late_types = []
+        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
+        missed_late_types = 0
+        while (late_type_vals = late_types.shift)
+          type_owner, lt = late_type_vals
+          if lt.is_a?(String)
+            type = Member::BuildType.constantize(lt)
+            # Reset the counter, since we might succeed next go-round
+            missed_late_types = 0
+            update_type_owner(type_owner, type)
+            add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+          elsif lt.is_a?(LateBoundType)
+            if (type = get_type(lt.name))
+              # Reset the counter, since we might succeed next go-round
+              missed_late_types = 0
+              update_type_owner(type_owner, type)
+              add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+            else
+              missed_late_types += 1
+              # Add it back to the list, maybe we'll be able to resolve it later.
+              late_types << [type_owner, lt]
+              if missed_late_types == late_types.size
+                # We've looked at all of them and haven't resolved one.
+                raise UnresolvedLateBoundTypeError.new(type: lt)
+              else
+                # Try the next one
+              end
+            end
+          else
+            raise ArgumentError, "Unexpected late type: #{lt.inspect}"
+          end
+        end
+        nil
+      end
+
+      def update_type_owner(owner, type)
+        case owner
+        when Class
+          if owner.kind.union?
+            # It's a union with possible_types
+            # Replace the item by class name
+            owner.assign_type_membership_object_type(type)
+            @possible_types[owner.graphql_name] = owner.possible_types
+          elsif type.kind.interface? && owner.kind.object?
+            new_interfaces = []
+            owner.interfaces.each do |int_t|
+              if int_t.is_a?(String) && int_t == type.graphql_name
+                new_interfaces << type
+              elsif int_t.is_a?(LateBoundType) && int_t.graphql_name == type.graphql_name
+                new_interfaces << type
+              else
+                # Don't re-add proper interface definitions,
+                # they were probably already added, maybe with options.
+              end
+            end
+            owner.implements(*new_interfaces)
+            new_interfaces.each do |int|
+              pt = @possible_types[int.graphql_name] ||= []
+              if !pt.include?(owner)
+                pt << owner
+              end
+            end
+          end
+
+        when nil
+          # It's a root type
+          @types[type.graphql_name] = type
+        when GraphQL::Schema::Field, GraphQL::Schema::Argument
+          orig_type = owner.type
+          # Apply list/non-null wrapper as needed
+          if orig_type.respond_to?(:of_type)
+            transforms = []
+            while (orig_type.respond_to?(:of_type))
+              if orig_type.kind.non_null?
+                transforms << :to_non_null_type
+              elsif orig_type.kind.list?
+                transforms << :to_list_type
+              else
+                raise "Invariant: :of_type isn't non-null or list"
+              end
+              orig_type = orig_type.of_type
+            end
+            transforms.reverse_each { |t| type = type.public_send(t) }
+          end
+          owner.type = type
+        else
+          raise "Unexpected update: #{owner.inspect} #{type.inspect}"
+        end
+      end
+
+      def add_type(type, owner:, late_types:, path:)
+        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
+          type_class = type.metadata[:type_class]
+          if type_class.nil?
+            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
+          else
+            type = type_class
+          end
+        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+          late_types << [owner, type]
+          return
+        end
+
+        if owner.is_a?(Class) && owner < GraphQL::Schema::Union
+          um = @union_memberships[type.graphql_name] ||= []
+          um << owner
+        end
+
+        if (prev_type = get_local_type(type.graphql_name))
+          if prev_type != type
+            raise DuplicateTypeNamesError.new(
+              type_name: type.graphql_name,
+              first_definition: prev_type,
+              second_definition: type,
+              path: path,
+            )
+          else
+            # This type was already added
+          end
+        elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
+          @directives << type
+          type.arguments.each do |name, arg|
+            arg_type = arg.type.unwrap
+            references_to(arg_type, from: arg)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path + [name])
+            if arg.default_value?
+              @arguments_with_default_values << arg
+            end
+          end
+        else
+          @types[type.graphql_name] = type
+          add_directives_from(type)
+          if type.kind.fields?
+            type.fields.each do |name, field|
+              field_type = field.type.unwrap
+              references_to(field_type, from: field)
+              field_path = path + [name]
+              add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              add_directives_from(field)
+              field.arguments.each do |arg_name, arg|
+                add_directives_from(arg)
+                arg_type = arg.type.unwrap
+                references_to(arg_type, from: arg)
+                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg_name])
+                if arg.default_value?
+                  @arguments_with_default_values << arg
+                end
+              end
+            end
+          end
+          if type.kind.input_object?
+            type.arguments.each do |arg_name, arg|
+              add_directives_from(arg)
+              arg_type = arg.type.unwrap
+              references_to(arg_type, from: arg)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg_name])
+              if arg.default_value?
+                @arguments_with_default_values << arg
+              end
+            end
+          end
+          if type.kind.union?
+            @possible_types[type.graphql_name] = type.possible_types
+            type.possible_types.each do |t|
+              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
+            end
+          end
+          if type.kind.interface?
+            type.orphan_types.each do |t|
+              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
+            end
+          end
+          if type.kind.object?
+            @possible_types[type.graphql_name] = [type]
+            type.interface_type_memberships.each do |interface_type_membership|
+              case interface_type_membership
+              when Schema::TypeMembership
+                interface_type = interface_type_membership.abstract_type
+                # We can get these now; we'll have to get late-bound types later
+                if interface_type.is_a?(Module)
+                  implementers = @possible_types[interface_type.graphql_name] ||= []
+                  implementers << type
+                end
+              when String, Schema::LateBoundType
+                interface_type = interface_type_membership
+              else
+                raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
+              end
+              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
+            end
+          end
+        end
+      end
+    end
+  end
+end