graphql 0.19.3 → 0.19.4

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -54,35 +54,52 @@ module GraphQL
           end
         end
 
-
         # Get the result of:
         # - Any middleware on this schema
         # - The field's resolve method
         # If the middleware chain returns a GraphQL::ExecutionError, its message
         # is added to the "errors" key.
         def get_raw_value
-          steps = execution_context.query.schema.middleware + [get_middleware_proc_from_field_resolve]
-          chain = GraphQL::Schema::MiddlewareChain.new(
-            steps: steps,
-            arguments: [parent_type, target, field, arguments, execution_context.query.context]
-          )
-          chain.call
+          middlewares = execution_context.query.schema.middleware
+          field_resolve_step = FieldResolveStep.new(irep_node)
+          resolve_arguments = [parent_type, target, field, arguments, execution_context.query.context]
+          # only run a middleware chain if there are any middleware
+          if middlewares.any?
+            chain = GraphQL::Schema::MiddlewareChain.new(
+              steps: middlewares + [field_resolve_step],
+              arguments: resolve_arguments
+            )
+            chain.call
+          else
+            field_resolve_step.call(*resolve_arguments)
+          end
         rescue GraphQL::ExecutionError => err
           err
         end
 
 
-        # Execute the field's resolve method
-        # @return [Proc] suitable to be the last step in a middleware chain
-        def get_middleware_proc_from_field_resolve
-          -> (_parent_type, parent_object, field_definition, field_args, context, _next) {
-            context.ast_node = irep_node.ast_node
-            context.irep_node = irep_node
+        # A `.call`-able suitable to be the last step in a middleware chain
+        class FieldResolveStep
+          def initialize(irep_node)
+            @irep_node = irep_node
+          end
+
+          # Execute the field's resolve method
+          def call(_parent_type, parent_object, field_definition, field_args, context, _next = nil)
+            # setup
+            context.ast_node = @irep_node.ast_node
+            context.irep_node = @irep_node
+
+            # resolve
             value = field_definition.resolve(parent_object, field_args, context)
+
+            # teardown
             context.ast_node = nil
             context.irep_node = nil
+
+            # return
             value
-          }
+          end
         end
       end
     end

data/lib/graphql/relay/base_connection.rb

@@ -74,7 +74,7 @@ module GraphQL
       deprecate(:object, :nodes, 2016, 9)
 
       # Provide easy access to provided arguments:
-      METHODS_FROM_ARGUMENTS = [:first, :after, :last, :before, :order]
+      METHODS_FROM_ARGUMENTS = [:first, :after, :last, :before]
 
       # @!method first
       #   The value passed as `first:`, if there was one
@@ -84,8 +84,6 @@ module GraphQL
       #   The value passed as `last:`, if there was one
       # @!method before
       #   The value passed as `before:`, if there was one
-      # @!method order
-      #   The value passed as `order:`, if there was one
       METHODS_FROM_ARGUMENTS.each do |arg_name|
         define_method(arg_name) do
           arguments[arg_name]

data/lib/graphql/relay/connection_type.rb

@@ -11,7 +11,7 @@ module GraphQL
           name(connection_type_name)
           field :edges, types[edge_type] do
             description "A list of edges."
-            resolve -> (obj, args, ctx) {
+            resolve ->(obj, args, ctx) {
               obj.edge_nodes.map { |item| edge_class.new(item, obj) }
             }
           end

data/lib/graphql/relay/mutation.rb

@@ -19,7 +19,7 @@ module GraphQL
     #
     #     return_field :item, ItemType
     #
-    #     resolve -> (inputs, ctx) {
+    #     resolve ->(inputs, ctx) {
     #       item = Item.find_by_id(inputs[:id])
     #       item.update(name: inputs[:name])
     #       {item: item}

data/lib/graphql/relay/relation_connection.rb

@@ -6,8 +6,13 @@ module GraphQL
     # - `Sequel::Dataset`
     class RelationConnection < BaseConnection
       def cursor_from_node(item)
-        offset = starting_offset + paged_nodes_array.index(item) + 1
-        Base64.strict_encode64(offset.to_s)
+        item_index = paged_nodes_array.index(item)
+        if item_index.nil?
+          raise("Can't generate cursor, item not found in connection: #{item}")
+        else
+          offset = starting_offset + item_index + 1
+          Base64.strict_encode64(offset.to_s)
+        end
       end
 
       def has_next_page
@@ -81,7 +86,6 @@ module GraphQL
       end
     end
 
-
     if defined?(ActiveRecord::Relation)
       BaseConnection.register_connection_implementation(ActiveRecord::Relation, RelationConnection)
     end

data/lib/graphql/scalar_type.rb

@@ -44,7 +44,7 @@ module GraphQL
     def validate_non_null_input(value)
       result = Query::InputValidationResult.new
       if coerce_non_null_input(value).nil?
-        result.add_problem("Could not coerce value #{JSON.dump(value)} to #{name}")
+        result.add_problem("Could not coerce value #{JSON.generate(value, quirks_mode: true)} to #{name}")
       end
       result
     end

data/lib/graphql/schema.rb

@@ -50,9 +50,9 @@ module GraphQL
       :max_depth, :max_complexity,
       :orphan_types, :resolve_type,
       :object_from_id, :id_from_object,
-      query_analyzer: -> (schema, analyzer) { schema.query_analyzers << analyzer },
-      middleware: -> (schema, middleware) { schema.middleware << middleware },
-      rescue_from: -> (schema, err_class, &block) { schema.rescue_from(err_class, &block)}
+      query_analyzer: ->(schema, analyzer) { schema.query_analyzers << analyzer },
+      middleware: ->(schema, middleware) { schema.middleware << middleware },
+      rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block)}
 
     lazy_defined_attr_accessor \
       :query, :mutation, :subscription,
@@ -61,7 +61,7 @@ module GraphQL
       :orphan_types,
       :query_analyzers, :middleware
 
-    DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective, GraphQL::Directive::DeprecatedDirective]
+    DIRECTIVES = [GraphQL::Directive::IncludeDirective, GraphQL::Directive::SkipDirective, GraphQL::Directive::DeprecatedDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
     attr_reader :directives, :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
@@ -86,8 +86,7 @@ module GraphQL
       @orphan_types = types
       @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
-      @rescue_middleware = GraphQL::Schema::RescueMiddleware.new
-      @middleware = [@rescue_middleware]
+      @middleware = []
       @query_analyzers = []
       @resolve_type_proc = nil
       @object_from_id_proc = nil
@@ -100,12 +99,12 @@ module GraphQL
 
     def rescue_from(*args, &block)
       ensure_defined
-      @rescue_middleware.rescue_from(*args, &block)
+      rescue_middleware.rescue_from(*args, &block)
     end
 
     def remove_handler(*args, &block)
       ensure_defined
-      @rescue_middleware.remove_handler(*args, &block)
+      rescue_middleware.remove_handler(*args, &block)
     end
 
     def define(**kwargs, &block)
@@ -258,5 +257,17 @@ module GraphQL
       ensure_defined
       @id_from_object_proc = new_proc
     end
+
+    private
+
+    # Lazily create a middleware and add it to the schema
+    # (Don't add it if it's not used)
+    def rescue_middleware
+      @rescue_middleware ||= begin
+        middleware = GraphQL::Schema::RescueMiddleware.new
+        @middleware << middleware
+        middleware
+      end
+    end
   end
 end

data/lib/graphql/schema/loader.rb

@@ -14,7 +14,7 @@ module GraphQL
         schema = introspection_result.fetch("data").fetch("__schema")
 
         types = {}
-        type_resolver = -> (type) { -> { resolve_type(types, type) } }
+        type_resolver = ->(type) { -> { resolve_type(types, type) } }
 
         schema.fetch("types").each do |type|
           next if type.fetch("name").start_with?("__")
@@ -31,7 +31,7 @@ module GraphQL
         Schema.define(**kargs)
       end
 
-      NullResolveType = -> (obj, ctx) {
+      NullResolveType = ->(obj, ctx) {
         raise(NotImplementedError, "This schema was loaded from string, so it can't resolve types for objects")
       }
 

data/lib/graphql/schema/printer.rb

@@ -18,7 +18,7 @@ module GraphQL
       # Return the GraphQL schema string for the introspection type system
       def print_introspection_schema
         query_root = ObjectType.define do
-          name "Query"
+          name "Root"
         end
         schema = GraphQL::Schema.define(query: query_root)
         print_filtered_schema(schema, method(:is_spec_directive), method(:is_introspection_type))
@@ -33,11 +33,18 @@ module GraphQL
         types = schema.types.values.select{ |type| type_filter.call(type) }.sort_by(&:name)
         type_definitions = types.map{ |type| print_type(type) }
 
-        [print_schema_definition(schema)].concat(directive_definitions)
+        [print_schema_definition(schema)].compact
+                                         .concat(directive_definitions)
                                          .concat(type_definitions).join("\n\n")
       end
 
       def print_schema_definition(schema)
+        if (schema.query.nil? || schema.query.name == 'Query') &&
+           (schema.mutation.nil? || schema.mutation.name == 'Mutation') &&
+           (schema.subscription.nil? || schema.subscription.name == 'Subscription')
+          return
+        end
+
         operations = [:query, :mutation, :subscription].map do |operation_type|
           object_type = schema.public_send(operation_type)
           "  #{operation_type}: #{object_type.name}\n" if object_type
@@ -84,10 +91,32 @@ module GraphQL
           end
         end
 
+        module DescriptionPrinter
+          def print_description(definition, indentation='', first_in_block=true)
+            return '' unless definition.description
+
+            description = indentation != '' && !first_in_block ? "\n" : ""
+            description << GraphQL::Language::Comments.commentize(definition.description, indent: indentation)
+          end
+        end
+
         module ArgsPrinter
-          def print_args(field)
+          include DescriptionPrinter
+          def print_args(field, indentation = '')
             return if field.arguments.empty?
-            "(#{field.arguments.values.map{ |arg| print_input_value(arg) }.join(", ")})"
+
+            field_arguments = field.arguments.values
+
+            if field_arguments.all?{ |arg| !arg.description }
+              return "(#{field_arguments.map{ |arg| print_input_value(arg) }.join(", ")})"
+            end
+
+            out = "(\n"
+            out << field_arguments.map.with_index{ |arg, i|
+              "#{print_description(arg, "  #{indentation}", i == 0)}  #{indentation}"\
+              "#{print_input_value(arg)}"
+            }.join("\n")
+            out << "\n)"
           end
 
           def print_input_value(arg)
@@ -131,64 +160,90 @@ module GraphQL
         module FieldPrinter
           include DeprecatedPrinter
           include ArgsPrinter
+          include DescriptionPrinter
           def print_fields(type)
-            type.all_fields.map{ |field|
-              "  #{field.name}#{print_args(field)}: #{field.type}#{print_deprecated(field)}"
+            type.all_fields.map.with_index{ |field, i|
+              "#{print_description(field, '  ', i == 0)}"\
+              "  #{field.name}#{print_args(field, '  ')}: #{field.type}#{print_deprecated(field)}"
             }.join("\n")
           end
         end
 
         class DirectivePrinter
           extend ArgsPrinter
+          extend DescriptionPrinter
           def self.print(directive)
+            "#{print_description(directive)}"\
             "directive @#{directive.name}#{print_args(directive)} "\
             "on #{directive.locations.join(' | ')}"
           end
         end
 
         class ScalarPrinter
+          extend DescriptionPrinter
           def self.print(type)
+            "#{print_description(type)}"\
             "scalar #{type.name}"
           end
         end
 
         class ObjectPrinter
           extend FieldPrinter
+          extend DescriptionPrinter
           def self.print(type)
             if type.interfaces.any?
               implementations = " implements #{type.interfaces.map(&:to_s).join(", ")}"
             else
               implementations = nil
             end
-            "type #{type.name}#{implementations} {\n#{print_fields(type)}\n}"
+
+            "#{print_description(type)}"\
+            "type #{type.name}#{implementations} {\n"\
+            "#{print_fields(type)}\n"\
+            "}"
           end
         end
 
         class InterfacePrinter
           extend FieldPrinter
+          extend DescriptionPrinter
           def self.print(type)
+            "#{print_description(type)}"\
             "interface #{type.name} {\n#{print_fields(type)}\n}"
           end
         end
 
         class UnionPrinter
+          extend DescriptionPrinter
           def self.print(type)
+            "#{print_description(type)}"\
             "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}"
           end
         end
 
         class EnumPrinter
           extend DeprecatedPrinter
+          extend DescriptionPrinter
           def self.print(type)
             values = type.values.values.map{ |v| "  #{v.name}#{print_deprecated(v)}" }.join("\n")
+            values = type.values.values.map.with_index { |v, i|
+              "#{print_description(v, '  ', i == 0)}"\
+              "  #{v.name}#{print_deprecated(v)}"
+            }.join("\n")
+            "#{print_description(type)}"\
             "enum #{type.name} {\n#{values}\n}"
           end
         end
 
         class InputObjectPrinter
           extend FieldPrinter
+          extend DescriptionPrinter
           def self.print(type)
-            fields = type.input_fields.values.map{ |field| "  #{print_input_value(field)}" }.join("\n")
+            fields = type.input_fields.values.map.with_index{ |field, i|
+              "#{print_description(field, "  ", i == 0)}"\
+              "  #{print_input_value(field)}"
+            }.join("\n")
+            "#{print_description(type)}"\
             "input #{type.name} {\n#{fields}\n}"
           end
         end

data/lib/graphql/schema/timeout_middleware.rb

@@ -50,18 +50,18 @@ module GraphQL
         end
         err
       end
-    end
 
-    # This error is raised when a query exceeds `max_seconds`.
-    # Since it's a child of {GraphQL::ExecutionError},
-    # its message will be added to the response's `errors` key.
-    #
-    # To raise an error that will stop query resolution, use a custom block
-    # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
-    # such as `RuntimeError`.
-    class GraphQL::Schema::TimeoutMiddleware::TimeoutError < GraphQL::ExecutionError
-      def initialize(parent_type, field_defn)
-        super("Timeout on #{parent_type.name}.#{field_defn.name}")
+      # This error is raised when a query exceeds `max_seconds`.
+      # Since it's a child of {GraphQL::ExecutionError},
+      # its message will be added to the response's `errors` key.
+      #
+      # To raise an error that will stop query resolution, use a custom block
+      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
+      # such as `RuntimeError`.
+      class TimeoutError < GraphQL::ExecutionError
+        def initialize(parent_type, field_defn)
+          super("Timeout on #{parent_type.name}.#{field_defn.name}")
+        end
       end
     end
   end

data/lib/graphql/schema/validation.rb

@@ -24,7 +24,7 @@ module GraphQL
         # @return [Proc] A proc which will validate the input by calling `property_name` and asserting it is an instance of one of `allowed_classes`
         def self.assert_property(property_name, *allowed_classes)
           allowed_classes_message = allowed_classes.map(&:name).join(" or ")
-          -> (obj) {
+          ->(obj) {
             property_value = obj.public_send(property_name)
             is_valid_value = allowed_classes.any? { |allowed_class| property_value.is_a?(allowed_class) }
             is_valid_value ? nil : "#{property_name} must return #{allowed_classes_message}, not #{property_value.class.name} (#{property_value.inspect})"
@@ -36,7 +36,7 @@ module GraphQL
         # @param to_class [Class] The class for values in the return value
         # @return [Proc] A proc to validate that validates the input by calling `property_name` and asserting that the return value is a Hash of `{from_class => to_class}` pairs
         def self.assert_property_mapping(property_name, from_class, to_class)
-          -> (obj) {
+          ->(obj) {
             property_value = obj.public_send(property_name)
             error_message = nil
             if !property_value.is_a?(Hash)
@@ -56,7 +56,7 @@ module GraphQL
         # @param list_member_class [Class] The class which each member of the returned array should be an instance of
         # @return [Proc] A proc to validate the input by calling `property_name` and asserting that the return is an Array of `list_member_class` instances
         def self.assert_property_list_of(property_name, list_member_class)
-          -> (obj) {
+          ->(obj) {
             property_value = obj.public_send(property_name)
             if !property_value.is_a?(Array)
               "#{property_name} must be an Array of #{list_member_class.name}, not a #{property_value.class.name} (#{property_value.inspect})"
@@ -72,7 +72,7 @@ module GraphQL
         end
 
         def self.assert_named_items_are_valid(item_name, get_items_proc)
-          -> (type) {
+          ->(type) {
             items = get_items_proc.call(type)
             error_message = nil
             items.each do |item|
@@ -87,18 +87,18 @@ module GraphQL
         end
 
 
-        FIELDS_ARE_VALID = Rules.assert_named_items_are_valid("field", -> (type) { type.all_fields })
+        FIELDS_ARE_VALID = Rules.assert_named_items_are_valid("field", ->(type) { type.all_fields })
 
-        HAS_ONE_OR_MORE_POSSIBLE_TYPES = -> (type) {
+        HAS_ONE_OR_MORE_POSSIBLE_TYPES = ->(type) {
           type.possible_types.length >= 1 ? nil : "must have at least one possible type"
         }
 
         NAME_IS_STRING = Rules.assert_property(:name, String)
         DESCRIPTION_IS_STRING_OR_NIL = Rules.assert_property(:description, String, NilClass)
         ARGUMENTS_ARE_STRING_TO_ARGUMENT = Rules.assert_property_mapping(:arguments, String, GraphQL::Argument)
-        ARGUMENTS_ARE_VALID =  Rules.assert_named_items_are_valid("argument", -> (type) { type.arguments.values })
+        ARGUMENTS_ARE_VALID =  Rules.assert_named_items_are_valid("argument", ->(type) { type.arguments.values })
 
-        DEFAULT_VALUE_IS_VALID_FOR_TYPE = -> (type) {
+        DEFAULT_VALUE_IS_VALID_FOR_TYPE = ->(type) {
           if !type.default_value.nil?
             coerced_value = begin
               type.type.coerce_result(type.default_value)
@@ -114,7 +114,7 @@ module GraphQL
           end
         }
 
-        TYPE_IS_VALID_INPUT_TYPE = -> (type) {
+        TYPE_IS_VALID_INPUT_TYPE = ->(type) {
           outer_type = type.type
           inner_type = outer_type.is_a?(GraphQL::BaseType) ? outer_type.unwrap : nil
 
@@ -126,7 +126,7 @@ module GraphQL
           end
         }
 
-        SCHEMA_CAN_RESOLVE_TYPES = -> (schema) {
+        SCHEMA_CAN_RESOLVE_TYPES = ->(schema) {
           if schema.types.values.any? { |type| type.kind.resolves? } && schema.resolve_type_proc.nil?
             "schema contains Interfaces or Unions, so you must define a `resolve_type (obj, ctx) -> { ... }` function"
           else
@@ -134,7 +134,7 @@ module GraphQL
           end
         }
 
-        SCHEMA_CAN_FETCH_IDS = -> (schema) {
+        SCHEMA_CAN_FETCH_IDS = ->(schema) {
           has_node_field = schema.query && schema.query.all_fields.any? { |f| f.metadata[:relay_node_field] }
           if has_node_field && schema.object_from_id_proc.nil?
             "schema contains `node(id:...)` field, so you must define a `object_from_id (id, ctx) -> { ... }` function"
@@ -143,7 +143,7 @@ module GraphQL
           end
         }
 
-        SCHEMA_CAN_GENERATE_IDS = -> (schema) {
+        SCHEMA_CAN_GENERATE_IDS = ->(schema) {
           has_id_field = schema.types.values.any? { |t| t.kind.fields? && t.all_fields.any? { |f| f.resolve_proc.is_a?(GraphQL::Relay::GlobalIdResolve) } }
           if has_id_field && schema.id_from_object_proc.nil?
             "schema contains `global_id_field`, so you must define a `id_from_object (obj, type, ctx) -> { ... }` function"