graphql 1.4.5 → 1.5.3

data/lib/graphql/relay/connection_resolve.rb

@@ -22,8 +22,13 @@ module GraphQL
       private
 
       def build_connection(nodes, args, parent, ctx)
-        connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
-        connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
+        if nodes.is_a? GraphQL::ExecutionError
+          ctx.add_error(nodes)
+          nil
+        else
+          connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
+          connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
+        end
       end
     end
   end

data/lib/graphql/relay/mutation.rb

@@ -48,6 +48,45 @@ module GraphQL
     #    #   }
     #    # }}
     #
+    # @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(
@@ -56,6 +95,7 @@ module GraphQL
         :return_interfaces,
         input_field: GraphQL::Define::AssignArgument,
         return_field: GraphQL::Define::AssignObjectField,
+        function: GraphQL::Define::AssignMutationFunction,
       )
       attr_accessor :name, :description, :fields, :arguments, :return_type, :return_interfaces
 
@@ -65,7 +105,6 @@ module GraphQL
         :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
@@ -128,10 +167,12 @@ module GraphQL
             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."
-            relay_mutation.input_fields.each do |input_field_name, field_obj|
+            relay_mutation.arguments.each do |input_field_name, field_obj|
               kwargs = {}
-              kwargs[:default_value] = field_obj.default_value if field_obj.default_value?
-              input_field input_field_name, field_obj.type, field_obj.description, **kwargs
+              if field_obj.default_value?
+                kwargs[:default_value] = field_obj.default_value
+              end
+              input_field(input_field_name, field_obj.type, field_obj.description, **kwargs)
             end
             mutation(relay_mutation)
           end

data/lib/graphql/relay/node.rb

@@ -4,27 +4,39 @@ module GraphQL
     # 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(resolve: nil)
+      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.
-        GraphQL::Field.define do
+        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(resolve || GraphQL::Relay::Node::FindNode)
+          resolve(GraphQL::Relay::Node::FindNode)
           relay_node_field(true)
         end
+
+        if kwargs.any? || block
+          field = field.redefine(kwargs, &block)
+        end
+
+        field
       end
 
-      def self.plural_field(resolve: nil)
-        GraphQL::Field.define do
+      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(resolve || GraphQL::Relay::Node::FindNodes)
+          resolve(GraphQL::Relay::Node::FindNodes)
           relay_nodes_field(true)
         end
+
+        if kwargs.any? || block
+          field = field.redefine(kwargs, &block)
+        end
+
+        field
       end
 
       # @return [GraphQL::InterfaceType] The interface which all Relay types must implement

data/lib/graphql/relay/range_add.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # This provides some isolation from `GraphQL::Relay` internals.
+    #
+    # Given a list of items and a new item, it will provide a connection and an edge.
+    #
+    # The connection doesn't receive outside arguments, so the list of items
+    # should be ordered and paginated before providing it here.
+    #
+    # @example Adding a comment to list of comments
+    #   post = Post.find(args[:postId])
+    #   comments = post.comments
+    #   new_comment = comments.build(body: args[:body])
+    #   new_comment.save!
+    #
+    #   range_add = GraphQL::Relay::RangeAdd.new(
+    #     parent: post,
+    #     collection: comments,
+    #     item: new_comment,
+    #     context: ctx,
+    #   )
+    #
+    #   response = {
+    #     post: post,
+    #     commentsConnection: range_add.connection,
+    #     newCommentEdge: range_add.edge,
+    #   }
+    class RangeAdd
+      attr_reader :edge, :connection, :parent
+
+      # @param collection [Object] The list of items to wrap in a connection
+      # @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)
+        @parent = parent
+        @connection = connection_class.new(collection, {}, parent: parent, context: context)
+        @edge = edge_class.new(item, @connection)
+      end
+    end
+  end
+end

data/lib/graphql/relay/relation_connection.rb

@@ -17,7 +17,7 @@ module GraphQL
       end
 
       def has_next_page
-        !!(first && count(sliced_nodes.limit(limit + 1)) > limit)
+        !!(first && paged_nodes && @has_next_page)
       end
 
       def has_previous_page
@@ -34,7 +34,22 @@ module GraphQL
 
       # apply first / last limit results
       def paged_nodes
-        @paged_nodes ||= sliced_nodes.limit(limit)
+        @paged_nodes ||= begin
+          if limit
+            limit_more = limit + 1
+            more_nodes = sliced_nodes.limit(limit_more).to_a
+            if more_nodes.size > limit
+              @has_next_page = true
+              more_nodes[0..-2]
+            else
+              @has_next_page = false
+              more_nodes
+            end
+          else
+            @has_next_page = false
+            sliced_nodes
+          end
+        end
       end
 
       # Apply cursors to edges

data/lib/graphql/runtime_type_error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class RuntimeTypeError < GraphQL::Error
   end

data/lib/graphql/schema.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/schema/base_64_encoder"
 require "graphql/schema/catchall_middleware"
+require "graphql/schema/default_parse_error"
 require "graphql/schema/default_type_error"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/instrumented_field_map"
@@ -55,12 +56,12 @@ module GraphQL
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
-      :orphan_types, :resolve_type, :type_error,
+      :orphan_types, :resolve_type, :type_error, :parse_error,
       :object_from_id, :id_from_object,
       :default_mask,
       :cursor_encoder,
       directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m  }},
-      instrument: -> (schema, type, instrumenter) { schema.instrumenters[type] << instrumenter },
+      instrument: ->(schema, type, instrumenter) { schema.instrumenters[type] << instrumenter },
       query_analyzer: ->(schema, analyzer) { schema.query_analyzers << analyzer },
       middleware: ->(schema, middleware) { schema.middleware << middleware },
       lazy_resolve: ->(schema, lazy_class, lazy_value_method) { schema.lazy_methods.set(lazy_class, lazy_value_method) },
@@ -103,6 +104,7 @@ module GraphQL
       @object_from_id_proc = nil
       @id_from_object_proc = nil
       @type_error_proc = DefaultTypeError
+      @parse_error_proc = DefaultParseError
       @instrumenters = Hash.new { |h, k| h[k] = [] }
       @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
       @cursor_encoder = Base64Encoder
@@ -148,6 +150,23 @@ module GraphQL
       rescue_middleware.remove_handler(*args, &block)
     end
 
+    # Validate a query string according to this schema.
+    # @param string_or_document [String, GraphQL::Language::Nodes::Document]
+    # @return [Array<GraphQL::StaticValidation::Message>]
+    def validate(string_or_document, rules: nil)
+      doc = if string_or_document.is_a?(String)
+        GraphQL.parse(string_or_document)
+      else
+        string_or_document
+      end
+      query = GraphQL::Query.new(self, document: doc)
+      validator_opts = { schema: self }
+      rules && (validator_opts[:rules] = rules)
+      validator = GraphQL::StaticValidation::Validator.new(validator_opts)
+      res = validator.validate(query)
+      res[:errors]
+    end
+
     def define(**kwargs, &block)
       super
       ensure_defined
@@ -316,6 +335,21 @@ module GraphQL
       @type_error_proc = new_proc
     end
 
+    # A function to call when {#execute} receives an invalid query string
+    #
+    # @see {DefaultParseError} is the default behavior.
+    # @param err [GraphQL::ParseError] The error encountered during parsing
+    # @param ctx [GraphQL::Query::Context] The context for the query where the error occurred
+    # @return void
+    def parse_error(err, ctx)
+      @parse_error_proc.call(err, ctx)
+    end
+
+    # @param new_proc [#call] A new callable for handling parse errors during execution
+    def parse_error=(new_proc)
+      @parse_error_proc = new_proc
+    end
+
     # Get a unique identifier from this object
     # @param object [Any] An application object
     # @param type [GraphQL::BaseType] The current type definition
@@ -342,10 +376,11 @@ module GraphQL
     end
 
     # Create schema from an IDL schema.
-    # @param definition_string String A schema definition string
+    # @param definition_string [String] A schema definition string
+    # @param default_resolve [<#call(type, field, obj, args, ctx)>] A callable for handling field resolution
     # @return [GraphQL::Schema] the schema described by `document`
-    def self.from_definition(definition_string)
-      GraphQL::Schema::BuildFromDefinition.from_definition(definition_string)
+    def self.from_definition(string, default_resolve: BuildFromDefinition::DefaultResolve)
+      GraphQL::Schema::BuildFromDefinition.from_definition(string, default_resolve: default_resolve)
     end
 
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.

data/lib/graphql/schema/base_64_encoder.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Schema
     # @api private

data/lib/graphql/schema/build_from_definition.rb

@@ -3,23 +3,57 @@ module GraphQL
   class Schema
     module BuildFromDefinition
       class << self
-        def from_definition(definition_string)
+        def from_definition(definition_string, default_resolve:)
           document = GraphQL::parse(definition_string)
-          Builder.build(document)
+          Builder.build(document, default_resolve: default_resolve)
         end
       end
 
+      # @api private
+      module DefaultResolve
+        def self.call(type, field, obj, args, ctx)
+          if field.arguments.any?
+            obj.public_send(field.name, args, ctx)
+          else
+            obj.public_send(field.name)
+          end
+        end
+      end
+
+      # @api private
+      class ResolveMap
+        def initialize(resolve_hash)
+          @resolve_hash = resolve_hash
+        end
+
+        def call(type, field, obj, args, ctx)
+          type_hash = @resolve_hash[type.name]
+          type_hash && (resolver = type_hash[field.name])
+
+          if resolver.nil?
+            raise(KeyError, "resolver not found for #{type.name}.#{field.name}")
+          else
+            resolver.call(obj, args, ctx)
+          end
+        end
+      end
+
+      # @api private
       module Builder
         extend self
 
-        def build(document)
+        def build(document, default_resolve: DefaultResolve)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
+          if default_resolve.is_a?(Hash)
+            default_resolve = ResolveMap.new(default_resolve)
+          end
+
           schema_definition = nil
           types = {}
           types.merge!(GraphQL::Schema::BUILT_IN_TYPES)
           directives = {}
-          type_resolver = -> (type) { -> { resolve_type(types, type) } }
+          type_resolver = ->(type) { -> { resolve_type(types, type) } }
 
           document.definitions.each do |definition|
             case definition
@@ -29,7 +63,7 @@ module GraphQL
             when GraphQL::Language::Nodes::EnumTypeDefinition
               types[definition.name] = build_enum_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ObjectTypeDefinition
-              types[definition.name] = build_object_type(definition, type_resolver)
+              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve)
             when GraphQL::Language::Nodes::InterfaceTypeDefinition
               types[definition.name] = build_interface_type(definition, type_resolver)
             when GraphQL::Language::Nodes::UnionTypeDefinition
@@ -81,7 +115,7 @@ module GraphQL
           end
         end
 
-        NullResolveType = -> (obj, ctx) {
+        NullResolveType = ->(obj, ctx) {
           raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution.")
         }
 
@@ -128,11 +162,13 @@ module GraphQL
           )
         end
 
-        def build_object_type(object_type_definition, type_resolver)
-          GraphQL::ObjectType.define(
+        def build_object_type(object_type_definition, type_resolver, default_resolve:)
+          type_def = nil
+          typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
+          type_def = GraphQL::ObjectType.define(
             name: object_type_definition.name,
             description: object_type_definition.description,
-            fields: Hash[build_fields(object_type_definition.fields, type_resolver)],
+            fields: Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)],
             interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
           )
         end
@@ -209,11 +245,11 @@ module GraphQL
           GraphQL::InterfaceType.define(
             name: interface_type_definition.name,
             description: interface_type_definition.description,
-            fields: Hash[build_fields(interface_type_definition.fields, type_resolver)],
+            fields: Hash[build_fields(interface_type_definition.fields, type_resolver, default_resolve: nil)],
           )
         end
 
-        def build_fields(field_definitions, type_resolver)
+        def build_fields(field_definitions, type_resolver, default_resolve:)
           field_definitions.map do |field_definition|
             field_arguments = Hash[field_definition.arguments.map do |argument|
               kwargs = {}
@@ -232,16 +268,15 @@ module GraphQL
               [argument.name, arg]
             end]
 
-            [
-              field_definition.name,
-              GraphQL::Field.define(
-                name: field_definition.name,
-                description: field_definition.description,
-                type: type_resolver.call(field_definition.type),
-                arguments: field_arguments,
-                deprecation_reason: build_deprecation_reason(field_definition.directives),
-              )
-            ]
+            field = GraphQL::Field.define(
+              name: field_definition.name,
+              description: field_definition.description,
+              type: type_resolver.call(field_definition.type),
+              arguments: field_arguments,
+              resolve: ->(obj, args, ctx) { default_resolve.call(field, obj, args, ctx) },
+              deprecation_reason: build_deprecation_reason(field_definition.directives),
+            )
+            [field_definition.name, field]
           end
         end