graphql 1.8.3 → 1.8.4

data/lib/graphql/schema/mutation.rb

@@ -114,6 +114,10 @@ module GraphQL
           @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
         end
 
+        def visible?(context)
+          true
+        end
+
         private
 
         # Build a subclass of {.object_class} based on `self`.

data/lib/graphql/schema/object.rb

@@ -12,6 +12,39 @@ module GraphQL
       # @return [GraphQL::Query::Context] the context instance for this query
       attr_reader :context
 
+      class << self
+        # This is protected so that we can be sure callers use the public method, {.authorized_new}
+        # @see authorized_new to make instances
+        protected :new
+
+        # Make a new instance of this type _if_ the auth check passes,
+        # otherwise, raise an error.
+        #
+        # Probably only the framework should call this method.
+        #
+        # This might return a {GraphQL::Execution::Lazy} if the user-provided `.authorized?`
+        # hook returns some lazy value (like a Promise).
+        #
+        # The reason that the auth check is in this wrapper method instead of {.new} is because
+        # of how it might return a Promise. It would be weird if `.new` returned a promise;
+        # It would be a headache to try to maintain Promise-y state inside a {Schema::Object}
+        # instance. So, hopefully this wrapper method will do the job.
+        #
+        # @param object [Object] The thing wrapped by this object
+        # @param context [GraphQL::Query::Context]
+        # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
+        # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
+        def authorized_new(object, context)
+          context.schema.after_lazy(authorized?(object, context)) do |is_authorized|
+            if is_authorized
+              self.new(object, context)
+            else
+              raise GraphQL::UnauthorizedError.new(object: object, type: self, context: context)
+            end
+          end
+        end
+      end
+
       def initialize(object, context)
         @object = object
         @context = context

data/lib/graphql/schema/possible_types.rb

@@ -22,6 +22,8 @@ module GraphQL
 
       def possible_types(type_defn)
         case type_defn
+        when Module
+          possible_types(type_defn.graphql_definition)
         when GraphQL::UnionType
           type_defn.possible_types
         when GraphQL::InterfaceType

data/lib/graphql/schema/resolver.rb

@@ -99,6 +99,15 @@ module GraphQL
           end
         end
 
+        # Specifies the complexity of the field. Defaults to `1`
+        # @return [Integer, Proc]
+        def complexity(new_complexity = nil)
+          if new_complexity
+            @complexity = new_complexity
+          end
+          @complexity || (superclass.respond_to?(:complexity) ? superclass.complexity : 1)
+        end
+
         def field_options
           {
             type: type_expr,
@@ -108,6 +117,7 @@ module GraphQL
             resolver_class: self,
             arguments: arguments,
             null: null,
+            complexity: complexity,
           }
         end
 

data/lib/graphql/schema/traversal.rb

@@ -16,13 +16,20 @@ module GraphQL
       # @return [Hash<String => Array<GraphQL::BaseType>]
       attr_reader :union_memberships
 
+
       # @param schema [GraphQL::Schema]
       def initialize(schema, introspection: true)
         @schema = schema
         @introspection = introspection
         @field_instrumenters =
           schema.instrumenters[:field] +
-            Schema::BUILT_IN_INSTRUMENTERS +
+            # Wrap Relay-related objects in wrappers
+            [
+              GraphQL::Relay::ConnectionInstrumentation,
+              GraphQL::Relay::EdgesInstrumentation,
+              GraphQL::Relay::Mutation::Instrumentation,
+              GraphQL::Schema::Member::Instrumentation,
+            ] +
             schema.instrumenters[:field_after_built_ins]
 
         # These fields have types specified by _name_,
@@ -158,7 +165,7 @@ Some late-bound types couldn't be resolved:
             end
           elsif !prev_type.equal?(type_defn)
             # If the previous entry in the map isn't the same object we just found, raise.
-            raise("Duplicate type definition found for name '#{type_defn.name}' (#{prev_type.metadata[:type_class]}, #{type_defn.metadata[:type_class]}})")
+            raise("Duplicate type definition found for name '#{type_defn.name}' at '#{context_description}' (#{prev_type.metadata[:type_class] || prev_type}, #{type_defn.metadata[:type_class] || type_defn})")
           end
         when Class
           if member.respond_to?(:graphql_definition)

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -20,8 +20,17 @@ module GraphQL
           type = context.schema.type_from_ast(node.type)
           if type.nil?
             # This is handled by another validator
-          elsif !context.valid_literal?(value, type)
-            context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node, context: context)
+          else
+            begin
+              valid = context.valid_literal?(value, type)
+            rescue GraphQL::CoercionError => err
+              error_message = err.message
+            end
+
+            if !valid
+              error_message ||= "Default value for $#{node.name} doesn't match type #{type}"
+              context.errors << message(error_message, node, context: context)
+            end
           end
         end
       end

data/lib/graphql/string_type.rb

@@ -1,3 +1,2 @@
 # frozen_string_literal: true
-require "graphql/types/string"
 GraphQL::STRING_TYPE = GraphQL::Types::String.graphql_definition

data/lib/graphql/types.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require "graphql/types/boolean"
+require "graphql/types/float"
+require "graphql/types/id"
+require "graphql/types/int"
+require "graphql/types/string"
+require "graphql/types/relay"

data/lib/graphql/types/relay.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require "graphql/types/relay/base_field"
+require "graphql/types/relay/base_object"
+require "graphql/types/relay/base_interface"
+require "graphql/types/relay/page_info"
+require "graphql/types/relay/base_connection"
+require "graphql/types/relay/base_edge"
+require "graphql/types/relay/node"
+
+module GraphQL
+  module Types
+    # This module contains some types and fields that could support Relay conventions in GraphQL.
+    #
+    # You can use these classes out of the box if you want, but if you want to use your _own_
+    # GraphQL extensions along with the features in this code, you could also
+    # open up the source files and copy the relevant methods and configuration into
+    # your own classes.
+    #
+    # For example, the provided object types extend {Types::Relay::BaseObject},
+    # but you might want to:
+    #
+    # 1. Migrate the extensions from {Types::Relay::BaseObject} into _your app's_ base object
+    # 2. Copy {Relay::BaseConnection}, {Relay::BaseEdge}, etc into _your app_, and
+    #   change them to extend _your_ base object.
+    #
+    # Similarly, `BaseField`'s extensions could be migrated to your app
+    # and `Node` could be implemented to mix in your base interface module.
+    module Relay
+    end
+  end
+end

data/lib/graphql/types/relay/base_connection.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      # Use this to implement Relay connections, or take it as inspiration
+      # for Relay classes in your own app.
+      #
+      # You may wish to copy this code into your own base class,
+      # so you can extend your own `BaseObject` instead of `GraphQL::Schema::Object`.
+      #
+      # @example Implementation a connection and edge
+      #   # Given some object in your app ...
+      #   class Types::Post < BaseObject
+      #   end
+      #
+      #   # Make a couple of base classes:
+      #   class Types::BaseEdge < GraphQL::Types::Relay::BaseEdge; end
+      #   class Types::BaseConnection < GraphQL::Types::Relay::BaseConnection; end
+      #
+      #   # Then extend them for the object in your app
+      #   class Types::PostEdge < Types::BaseEdge
+      #     node_type(Types::Post)
+      #   end
+      #   class Types::PostConnection < Types::BaseConnection
+      #     edge_type(Types::PostEdge)
+      #   end
+      #
+      # @see Relay::BaseEdge for edge types
+      class BaseConnection < Types::Relay::BaseObject
+        extend Forwardable
+        def_delegators :@object, :cursor_from_node, :parent
+
+        class << self
+          # @return [Class]
+          attr_reader :node_type
+
+          # @return [Class]
+          attr_reader :edge_type
+
+          # Configure this connection to return `edges` and `nodes` based on `edge_type_class`.
+          #
+          # This method will use the inputs to create:
+          # - `edges` field
+          # - `nodes` field
+          # - description
+          #
+          # It's called when you subclass this base connection, trying to use the
+          # class name to set defaults. You can call it again in the class definition
+          # to override the default (or provide a value, if the default lookup failed).
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type)
+            # Set this connection's graphql name
+            node_type_name = node_type.graphql_name
+
+            @node_type = node_type
+            @edge_type = edge_type_class
+
+            field :edges, [edge_type_class, null: true],
+              null: true,
+              description: "A list of edges.",
+              method: :edge_nodes,
+              edge_class: edge_class
+
+            field :nodes, [node_type, null: true],
+              null: true,
+              description: "A list of nodes."
+
+            description("The connection type for #{node_type_name}.")
+          end
+
+          # Add the shortcut `nodes` field to this connection and its subclasses
+          def nodes_field
+            field :nodes, [@node_type, null: true], null: true
+          end
+        end
+
+        field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
+
+        # By default this calls through to the ConnectionWrapper's edge nodes method,
+        # but sometimes you need to override it to support the `nodes` field
+        def nodes
+          @object.edge_nodes
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/base_edge.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    module Relay
+      # A class-based definition for Relay edges.
+      #
+      # Use this as a parent class in your app, or use it as inspiration for your
+      # own base `Edge` class.
+      #
+      # For example, you may want to extend your own `BaseObject` instead of the
+      # built-in `GraphQL::Schema::Object`.
+      #
+      # @example Making a UserEdge type
+      #   # Make a base class for your app
+      #   class Types::BaseEdge < GraphQL::Types::Relay::BaseEdge
+      #   end
+      #
+      #   # Then extend your own base class
+      #   class Types::UserEdge < Types::BaseEdge
+      #     node_type(Types::User)
+      #   end
+      #
+      # @see {Relay::BaseConnection} for connection types
+      class BaseEdge < Types::Relay::BaseObject
+        description "An edge in a connection."
+
+        class << self
+          # Get or set the Object type that this edge wraps.
+          #
+          # @param node_type [Class] A `Schema::Object` subclass
+          def node_type(node_type = nil)
+            if node_type
+              @node_type = node_type
+              wrapped_type_name = node_type.graphql_name
+              # Set this to be named like the node type, but suffixed with `Edge`
+              graphql_name("#{wrapped_type_name}Edge")
+              # Add a default `node` field
+              field :node, node_type, null: true, description: "The item at the end of the edge."
+            end
+            @node_type
+          end
+        end
+
+
+        field :cursor, String,
+          null: false,
+          description: "A cursor for use in pagination."
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/base_field.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      class BaseField < GraphQL::Schema::Field
+        def initialize(edge_class: nil, **rest, &block)
+          @edge_class = edge_class
+          super(**rest, &block)
+        end
+
+        def to_graphql
+          field = super
+          if @edge_class
+            field.edge_class = @edge_class
+          end
+          field
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/base_interface.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module BaseInterface
+        include GraphQL::Schema::Interface
+
+        field_class(Types::Relay::BaseField)
+
+        definition_methods do
+          def default_relay(new_value)
+            @default_relay = new_value
+          end
+
+          def default_relay?
+            !!@default_relay
+          end
+
+          def to_graphql
+            type_defn = super
+            type_defn.default_relay = default_relay?
+            type_defn
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/base_object.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      class BaseObject < GraphQL::Schema::Object
+        field_class(Types::Relay::BaseField)
+        class << self
+          def default_relay(new_value)
+            @default_relay = new_value
+          end
+
+          def default_relay?
+            !!@default_relay
+          end
+
+          def to_graphql
+            type_defn = super
+            type_defn.default_relay = default_relay?
+            type_defn
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      # This can be used for Relay's `Node` interface,
+      # or you can take it as inspiration for your own implementation
+      # of the `Node` interface.
+      module Node
+        include Types::Relay::BaseInterface
+        default_relay(true)
+        description "An object with an ID."
+        field(:id, ID, null: false, description: "ID of the object.")
+        # TODO Should I implement `id` here to call the schema's hook?
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/page_info.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    module Relay
+      # The return type of a connection's `pageInfo` field
+      class PageInfo < Types::Relay::BaseObject
+        default_relay true
+        description "Information about pagination in a connection."
+        field :has_next_page, Boolean, null: false,
+          description: "When paginating forwards, are there more items?"
+
+        field :has_previous_page, Boolean, null: false,
+          description: "When paginating backwards, are there more items?"
+
+        field :start_cursor, String, null: true,
+          description: "When paginating backwards, the cursor to continue."
+
+        field :end_cursor, String, null: true,
+          description: "When paginating forwards, the cursor to continue."
+      end
+    end
+  end
+end