graphql 1.3.0 → 1.4.0

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

@@ -77,33 +77,12 @@ module GraphQL
         # If the middleware chain returns a GraphQL::ExecutionError, its message
         # is added to the "errors" key.
         def get_raw_value
-          middlewares = @query.schema.middleware
-
-          resolve_arguments = [parent_type, target, field, arguments, @field_ctx]
-
           begin
-            # only run a middleware chain if there are any middleware
-            if middlewares.any?
-              chain = GraphQL::Schema::MiddlewareChain.new(
-                steps: middlewares + [FieldResolveStep],
-                arguments: resolve_arguments
-              )
-              chain.call
-            else
-              FieldResolveStep.call(*resolve_arguments)
-            end
+            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx])
           rescue GraphQL::ExecutionError => err
             err
           end
         end
-
-        # A `.call`-able suitable to be the last step in a middleware chain
-        module FieldResolveStep
-          # Execute the field's resolve method
-          def self.call(_parent_type, parent_object, field_definition, field_args, context, _next = nil)
-            field_definition.resolve(parent_object, field_args, context)
-          end
-        end
       end
     end
   end

data/lib/graphql/relay/array_connection.rb

@@ -32,7 +32,7 @@ module GraphQL
 
       # Apply cursors to edges
       def sliced_nodes
-        @sliced_nodes ||= nodes[starting_offset..-1]
+        @sliced_nodes ||= nodes[starting_offset..-1] || []
       end
 
       def index_from_cursor(cursor)
@@ -42,6 +42,8 @@ module GraphQL
       def starting_offset
         @starting_offset = if before
           [previous_offset, 0].max
+        elsif last
+          nodes.count - last
         else
           previous_offset
         end

data/lib/graphql/relay/connection_type.rb

@@ -2,8 +2,14 @@
 module GraphQL
   module Relay
     module ConnectionType
+      class << self
+        attr_accessor :default_nodes_field
+      end
+
+      self.default_nodes_field = false
+
       # Create a connection which exposes edges of this type
-      def self.create_type(wrapped_type, edge_type: nil, edge_class: nil, &block)
+      def self.create_type(wrapped_type, edge_type: nil, edge_class: nil, nodes_field: ConnectionType.default_nodes_field, &block)
         edge_type ||= wrapped_type.edge_type
         edge_class ||= GraphQL::Relay::Edge
         connection_type_name = "#{wrapped_type.name}Connection"
@@ -16,6 +22,14 @@ module GraphQL
               obj.edge_nodes.map { |item| edge_class.new(item, obj) }
             }
           end
+          if nodes_field
+            field :nodes, types[wrapped_type] do
+              description "A list of nodes."
+              resolve ->(obj, args, ctx) {
+                obj.edge_nodes
+              }
+            end
+          end
           field :pageInfo, !PageInfo, "Information to aid in pagination.", property: :page_info
           block && instance_eval(&block)
         end

data/lib/graphql/relay/node.rb

@@ -23,6 +23,7 @@ module GraphQL
           name "Node"
           description "An object with an ID."
           field :id, !types.ID, "ID of the object."
+          default_relay true
         end
       end
 

data/lib/graphql/relay/page_info.rb

@@ -9,6 +9,7 @@ module GraphQL
       field :hasPreviousPage, !types.Boolean, "Indicates if there are any pages prior to the current page", 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
   end
 end

data/lib/graphql/relay/relation_connection.rb

@@ -44,6 +44,8 @@ module GraphQL
         @starting_offset ||= begin
           if before
             [previous_offset, 0].max
+          elsif last
+            nodes.count - last
           else
             previous_offset
           end

data/lib/graphql/schema.rb

@@ -5,6 +5,7 @@ require "graphql/schema/default_type_error"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/instrumented_field_map"
 require "graphql/schema/middleware_chain"
+require "graphql/schema/null_mask"
 require "graphql/schema/possible_types"
 require "graphql/schema/rescue_middleware"
 require "graphql/schema/reduce_types"
@@ -56,11 +57,12 @@ module GraphQL
       :max_depth, :max_complexity,
       :orphan_types, :resolve_type, :type_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 },
       query_analyzer: ->(schema, analyzer) { schema.query_analyzers << analyzer },
-      middleware: ->(schema, middleware) { schema.user_middleware << middleware },
+      middleware: ->(schema, middleware) { schema.middleware << middleware },
       lazy_resolve: ->(schema, lazy_class, lazy_value_method) { schema.lazy_methods.set(lazy_class, lazy_value_method) },
       rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block)}
 
@@ -69,9 +71,16 @@ module GraphQL
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
       :orphan_types, :directives,
-      :query_analyzers, :user_middleware, :instrumenters, :lazy_methods,
+      :query_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder
 
+    # @return [MiddlewareChain] MiddlewareChain which is applied to fields during execution
+    attr_accessor :middleware
+
+    # @return [<#call(member, ctx)>] A callable for filtering members of the schema
+    # @see {Query.new} for query-specific filters with `except:`
+    attr_accessor :default_mask
+
     class << self
       attr_accessor :default_execution_strategy
     end
@@ -88,7 +97,7 @@ module GraphQL
       @orphan_types = []
       @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
-      @user_middleware = []
+      @middleware = MiddlewareChain.new(final_step: GraphQL::Execution::Execute::FieldResolveStep)
       @query_analyzers = []
       @resolve_type_proc = nil
       @object_from_id_proc = nil
@@ -101,6 +110,7 @@ module GraphQL
       @query_execution_strategy = self.class.default_execution_strategy
       @mutation_execution_strategy = self.class.default_execution_strategy
       @subscription_execution_strategy = self.class.default_execution_strategy
+      @default_mask = GraphQL::Schema::NullMask
     end
 
     def initialize_copy(other)
@@ -108,8 +118,7 @@ module GraphQL
       @orphan_types = other.orphan_types.dup
       @directives = other.directives.dup
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
-      @user_middleware = other.user_middleware.dup
-      @middleware = nil
+      @middleware = other.middleware.dup
       @query_analyzers = other.query_analyzers.dup
 
       @possible_types = GraphQL::Schema::PossibleTypes.new(self)
@@ -349,13 +358,12 @@ module GraphQL
       !!lazy_method_name(obj)
     end
 
-    # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
-    def middleware
-      @middleware ||= if @rescue_middleware
-        [@rescue_middleware].concat(@user_middleware)
-      else
-        @user_middleware
-      end
+    # Return a GraphQL schema string for the defined types in the schema
+    # @param context [Hash]
+    # @param only [<#call(member, ctx)>]
+    # @param except [<#call(member, ctx)>]
+    def to_definition(only: nil, except: nil, context: {})
+      GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
     end
 
     protected
@@ -367,7 +375,7 @@ module GraphQL
     # Lazily create a middleware and add it to the schema
     # (Don't add it if it's not used)
     def rescue_middleware
-      @rescue_middleware ||= GraphQL::Schema::RescueMiddleware.new
+      @rescue_middleware ||= GraphQL::Schema::RescueMiddleware.new.tap { |m| middleware.insert(0, m) }
     end
 
     private

data/lib/graphql/schema/catchall_middleware.rb

@@ -25,8 +25,8 @@ module GraphQL
 
       # Rescue any error and replace it with a {GraphQL::ExecutionError}
       # whose message is {MESSAGE}
-      def self.call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
-        next_middleware.call
+      def self.call(parent_type, parent_object, field_definition, field_args, query_context)
+        yield
       rescue StandardError => err
         GraphQL::ExecutionError.new(MESSAGE)
       end

data/lib/graphql/schema/middleware_chain.rb

@@ -5,24 +5,82 @@ module GraphQL
     #
     # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
     class MiddlewareChain
+      extend Forwardable
+
       # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
-      attr_reader :steps
+      attr_reader :steps, :final_step
+
+      def initialize(steps: [], final_step: nil)
+        @steps = steps
+        @final_step = final_step
+      end
+
+      def initialize_copy(other)
+        super
+        @steps = other.steps.dup
+      end
+
+      def_delegators :@steps, :[], :first, :insert, :delete
 
-      # @return [Array] Arguments passed to steps (followed by `next_middleware`)
-      attr_reader :arguments
+      def <<(callable)
+        add_middleware(callable)
+      end
+
+      def push(callable)
+        add_middleware(callable)
+      end
+
+      def ==(other)
+        steps == other.steps && final_step == other.final_step
+      end
+
+      def invoke(arguments)
+        invoke_core(0, arguments)
+      end
+
+      private
+
+      def invoke_core(index, arguments)
+        if index >= steps.length
+          final_step.call(*arguments)
+        else
+          steps[index].call(*arguments) { |next_args = arguments| invoke_core(index + 1, next_args) }
+        end
+      end
+
+      def add_middleware(callable)
+        # TODO: Stop wrapping callables once deprecated middleware becomes unsupported
+        steps << wrap(callable)
+      end
+
+      # TODO: Remove this code once deprecated middleware becomes unsupported
+      class MiddlewareWrapper
+        attr_reader :callable
+        def initialize(callable)
+          @callable = callable
+        end
+
+        def call(*args, &next_middleware)
+          callable.call(*args, next_middleware)
+        end
+      end
 
-      def initialize(steps:, arguments:)
-        # We're gonna destroy this array, so copy it:
-        @steps = steps.dup
-        @arguments = arguments
+      def wrap(callable)
+        if get_arity(callable) == 6
+          warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
+          MiddlewareWrapper.new(callable)
+        else
+          callable
+        end
       end
 
-      # Run the next step in the chain, passing in arguments and handle to the next step
-      def call(next_arguments = @arguments)
-        @arguments = next_arguments
-        next_step = steps.shift
-        next_middleware = self
-        next_step.call(*arguments, next_middleware)
+      def get_arity(callable)
+        case callable
+        when Proc, Method
+          callable.arity
+        else
+          callable.method(:call).arity
+        end
       end
     end
   end

data/lib/graphql/schema/null_mask.rb

@@ -0,0 +1,10 @@
+module GraphQL
+  class Schema
+    # @api private
+    module NullMask
+      def self.call(member, ctx)
+        false
+      end
+    end
+  end
+end

data/lib/graphql/schema/printer.rb

@@ -11,35 +11,66 @@ module GraphQL
       extend self
 
       # Return a GraphQL schema string for the defined types in the schema
+      # @param context [Hash]
+      # @param only [<#call(member, ctx)>]
+      # @param except [<#call(member, ctx)>]
       # @param schema [GraphQL::Schema]
-      def print_schema(schema)
-        print_filtered_schema(schema, lambda { |n| !is_spec_directive(n) }, method(:is_defined_type))
+      def print_schema(schema, context: nil, only: nil, except: nil)
+        blacklist = if only
+          ->(m, ctx) { !(IS_USER_DEFINED_MEMBER.call(m) && only.call(m, ctx)) }
+        elsif except
+          ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) || except.call(m, ctx) }
+        else
+          ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) }
+        end
+
+        warden = GraphQL::Schema::Warden.new(blacklist, schema: schema, context: context)
+
+        print_filtered_schema(schema, warden: warden)
       end
 
       # Return the GraphQL schema string for the introspection type system
       def print_introspection_schema
-        query_root = ObjectType.define do
-          name "Root"
-        end
+        query_root = ObjectType.define(name: "Root")
         schema = GraphQL::Schema.define(query: query_root)
-        print_filtered_schema(schema, method(:is_spec_directive), method(:is_introspection_type))
+        blacklist = ->(m, ctx) { m == query_root }
+
+        warden = GraphQL::Schema::Warden.new(blacklist, schema: schema, context: nil)
+
+        print_filtered_schema(schema, warden: warden)
       end
 
       private
 
-      def print_filtered_schema(schema, directive_filter, type_filter)
-        directives = schema.directives.values.select{ |directive| directive_filter.call(directive) }
-        directive_definitions = directives.map{ |directive| print_directive(directive) }
+      # By default, these are included in a schema printout
+      IS_USER_DEFINED_MEMBER = ->(member) {
+        case member
+        when GraphQL::BaseType
+          !member.introspection?
+        when GraphQL::Directive
+          !member.default_directive?
+        else
+          true
+        end
+      }
+
+      private_constant :IS_USER_DEFINED_MEMBER
+
+      def print_filtered_schema(schema, warden:)
+        directive_definitions = warden.directives.map { |directive| print_directive(warden, directive) }
 
-        types = schema.types.values.select{ |type| type_filter.call(type) }.sort_by(&:name)
-        type_definitions = types.map{ |type| print_type(type) }
+        printable_types = warden.types.reject(&:default_scalar?)
 
-        [print_schema_definition(schema)].compact
+        type_definitions = printable_types
+          .sort_by(&:name)
+          .map { |type| print_type(warden, type) }
+
+        [print_schema_definition(warden, schema)].compact
                                          .concat(directive_definitions)
                                          .concat(type_definitions).join("\n\n")
       end
 
-      def print_schema_definition(schema)
+      def print_schema_definition(warden, schema)
         if (schema.query.nil? || schema.query.name == 'Query') &&
            (schema.mutation.nil? || schema.mutation.name == 'Mutation') &&
            (schema.subscription.nil? || schema.subscription.name == 'Subscription')
@@ -48,32 +79,22 @@ module GraphQL
 
         operations = [:query, :mutation, :subscription].map do |operation_type|
           object_type = schema.public_send(operation_type)
-          "  #{operation_type}: #{object_type.name}\n" if object_type
+          # Special treatment for the introspection schema, which prints `{ query: "Root" }`
+          if object_type && (warden.get_type(object_type.name) || (object_type.name == "Root" && schema.query == object_type))
+            "  #{operation_type}: #{object_type.name}\n"
+          else
+            nil
+          end
         end.compact.join
         "schema {\n#{operations}}"
       end
 
-      BUILTIN_SCALARS = Set.new(["String", "Boolean", "Int", "Float", "ID"])
-      private_constant :BUILTIN_SCALARS
-
-      def is_spec_directive(directive)
-        ['skip', 'include', 'deprecated'].include?(directive.name)
-      end
-
-      def is_introspection_type(type)
-        type.name.start_with?("__")
-      end
-
-      def is_defined_type(type)
-        !is_introspection_type(type) && !BUILTIN_SCALARS.include?(type.name)
+      def print_type(warden, type)
+        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(warden, type)
       end
 
-      def print_type(type)
-        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(type)
-      end
-
-      def print_directive(directive)
-        TypeKindPrinters::DirectivePrinter.print(directive)
+      def print_directive(warden, directive)
+        TypeKindPrinters::DirectivePrinter.print(warden, directive)
       end
 
       module TypeKindPrinters
@@ -103,17 +124,16 @@ module GraphQL
 
         module ArgsPrinter
           include DescriptionPrinter
-          def print_args(field, indentation = '')
-            return if field.arguments.empty?
-
-            field_arguments = field.arguments.values
+          def print_args(warden, field, indentation = '')
+            arguments = warden.arguments(field)
+            return if arguments.empty?
 
-            if field_arguments.all?{ |arg| !arg.description }
-              return "(#{field_arguments.map{ |arg| print_input_value(arg) }.join(", ")})"
+            if arguments.all?{ |arg| !arg.description }
+              return "(#{arguments.map{ |arg| print_input_value(arg) }.join(", ")})"
             end
 
             out = "(\n".dup
-            out << field_arguments.map.with_index{ |arg, i|
+            out << arguments.map.with_index{ |arg, i|
               "#{print_description(arg, "  #{indentation}", i == 0)}  #{indentation}"\
               "#{print_input_value(arg)}"
             }.join("\n")
@@ -169,10 +189,11 @@ module GraphQL
           include DeprecatedPrinter
           include ArgsPrinter
           include DescriptionPrinter
-          def print_fields(type)
-            type.all_fields.map.with_index { |field, i|
+          def print_fields(warden, type)
+            fields = warden.fields(type)
+            fields.map.with_index { |field, i|
               "#{print_description(field, '  ', i == 0)}"\
-              "  #{field.name}#{print_args(field, '  ')}: #{field.type}#{print_deprecated(field)}"
+              "  #{field.name}#{print_args(warden, field, '  ')}: #{field.type}#{print_deprecated(field)}"
             }.join("\n")
           end
         end
@@ -180,16 +201,16 @@ module GraphQL
         class DirectivePrinter
           extend ArgsPrinter
           extend DescriptionPrinter
-          def self.print(directive)
+          def self.print(warden, directive)
             "#{print_description(directive)}"\
-            "directive @#{directive.name}#{print_args(directive)} "\
+            "directive @#{directive.name}#{print_args(warden, directive)} "\
             "on #{directive.locations.join(' | ')}"
           end
         end
 
         class ScalarPrinter
           extend DescriptionPrinter
-          def self.print(type)
+          def self.print(warden, type)
             "#{print_description(type)}"\
             "scalar #{type.name}"
           end
@@ -198,16 +219,17 @@ module GraphQL
         class ObjectPrinter
           extend FieldPrinter
           extend DescriptionPrinter
-          def self.print(type)
-            if type.interfaces.any?
-              implementations = " implements #{type.interfaces.map(&:to_s).join(", ")}"
+          def self.print(warden, type)
+            interfaces = warden.interfaces(type)
+            if interfaces.any?
+              implementations = " implements #{interfaces.map(&:to_s).join(", ")}"
             else
               implementations = nil
             end
 
             "#{print_description(type)}"\
             "type #{type.name}#{implementations} {\n"\
-            "#{print_fields(type)}\n"\
+            "#{print_fields(warden, type)}\n"\
             "}"
           end
         end
@@ -215,29 +237,32 @@ module GraphQL
         class InterfacePrinter
           extend FieldPrinter
           extend DescriptionPrinter
-          def self.print(type)
+          def self.print(warden, type)
             "#{print_description(type)}"\
-            "interface #{type.name} {\n#{print_fields(type)}\n}"
+            "interface #{type.name} {\n#{print_fields(warden, type)}\n}"
           end
         end
 
         class UnionPrinter
           extend DescriptionPrinter
-          def self.print(type)
+          def self.print(warden, type)
+            possible_types = warden.possible_types(type)
             "#{print_description(type)}"\
-            "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}"
+            "union #{type.name} = #{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|
+          def self.print(warden, type)
+            enum_values = warden.enum_values(type)
+
+            values = enum_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
@@ -246,8 +271,9 @@ module GraphQL
         class InputObjectPrinter
           extend FieldPrinter
           extend DescriptionPrinter
-          def self.print(type)
-            fields = type.input_fields.values.map.with_index{ |field, i|
+          def self.print(warden, type)
+            arguments = warden.arguments(type)
+            fields = arguments.map.with_index{ |field, i|
               "#{print_description(field, "  ", i == 0)}"\
               "  #{print_input_value(field)}"
             }.join("\n")