graphql 0.9.4 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7a6017d64f6fd507c50ac439cd6509e2fb163cd
-  data.tar.gz: 43f4acf1bd7a7b7bf43b9b0df7e87d34cea37339
+  metadata.gz: e860d8ee6cbcf24b38c43ea7182153e9e1ea6c17
+  data.tar.gz: 6ffcb982ea45a2e3c16fb68726a1c583849f5184
 SHA512:
-  metadata.gz: 313db517b3541bbf8f21a7d1fba1eb257d4be306e44e33f9f6f511d0d3fbfb034cfeca667a2025038bc85b88513fa329db7003922948dd64a78633c44231eb2c
-  data.tar.gz: 2a86be1427279e98dfb940ac59f2b8669c6d9638ad8a414a34ba80ee87a9d32bcde0a5ccef2d9c660d033b8d6a7be7ad0c1902869a33c5fe711b24d4cf9512b8
+  metadata.gz: 6990e5ed872ebf7efed61846915a57ed7e21b76ab82ea9c33233bb4747cdb49c435c2e2d2f0a7b8942dbded68800ca54fe517643a9b1bb4a1fb3cfc0f1cd98c4
+  data.tar.gz: a4740639e811cd70e43b01fa22e8a9d35005b5825778bfa1b5ce31940cf1fc9dc8bb2fc2c262579cd2548645bfc982054fa055eae4ea3d9e4c941015f789def5

data/lib/graphql.rb

@@ -1,6 +1,7 @@
 require "json"
 require "parslet"
 require "singleton"
+require "forwardable"
 
 module GraphQL
   class ParseError < StandardError
@@ -55,6 +56,7 @@ require 'graphql/introspection'
 require 'graphql/language'
 require 'graphql/directive'
 require 'graphql/schema'
+require 'graphql/schema/printer'
 
 # Order does not matter for these:
 

data/lib/graphql/base_type.rb

@@ -59,25 +59,11 @@ module GraphQL
       end
     end
 
-    # Print the human-readable name of this type
+    # Print the human-readable name of this type using the query-string naming pattern
     def to_s
-      Printer.instance.print(self)
+      name
     end
 
     alias :inspect :to_s
-
-    # Print a type, using the query-style naming pattern
-    class Printer
-      include Singleton
-      def print(type)
-        if type.kind.non_null?
-          "#{print(type.of_type)}!"
-        elsif type.kind.list?
-          "[#{print(type.of_type)}]"
-        else
-          type.name
-        end
-      end
-    end
   end
 end

data/lib/graphql/introspection/arguments_field.rb

@@ -1,5 +1,5 @@
 GraphQL::Introspection::ArgumentsField = GraphQL::Field.define do
   description "Arguments allowed to this object"
-  type GraphQL::ListType.new(of_type: GraphQL::Introspection::InputValueType)
+  type !GraphQL::ListType.new(of_type: !GraphQL::Introspection::InputValueType)
   resolve -> (target, a, c) { target.arguments.values }
 end

data/lib/graphql/introspection/field_type.rb

@@ -2,7 +2,7 @@ GraphQL::Introspection::FieldType = GraphQL::ObjectType.define do
   name "__Field"
   description "Field on a GraphQL type"
   field :name, !types.String, "The name for accessing this field"
-  field :description, !types.String, "The description of this field"
+  field :description, types.String, "The description of this field"
   field :type, !GraphQL::Introspection::TypeType, "The return type of this field"
   field :isDeprecated, !types.Boolean, "Is this field deprecated?" do
       resolve -> (obj, a, c) { !!obj.deprecation_reason }

data/lib/graphql/introspection/input_fields_field.rb

@@ -1,7 +1,7 @@
 GraphQL::Introspection::InputFieldsField = GraphQL::Field.define do
   name "inputFields"
   description "fields on this input object"
-  type types[GraphQL::Introspection::InputValueType]
+  type types[!GraphQL::Introspection::InputValueType]
   resolve -> (target, a, c) {
     if target.kind.input_object?
       target.input_fields.values

data/lib/graphql/introspection/input_value_type.rb

@@ -3,6 +3,6 @@ GraphQL::Introspection::InputValueType = GraphQL::ObjectType.define do
   description "An input for a field or InputObject"
   field :name, !types.String, "The key for this value"
   field :description, types.String, "What this value is used for"
-  field :type, -> { GraphQL::Introspection::TypeType }, "The expected type for this value"
+  field :type, -> { !GraphQL::Introspection::TypeType }, "The expected type for this value"
   field :defaultValue, types.String, "The value applied if no other value is provided", property: :default_value
 end

data/lib/graphql/introspection/interfaces_field.rb

@@ -1,5 +1,5 @@
 GraphQL::Introspection::InterfacesField = GraphQL::Field.define do
   description "Interfaces which this object implements"
-  type -> { !types[!GraphQL::Introspection::TypeType] }
+  type -> { types[!GraphQL::Introspection::TypeType] }
   resolve -> (target, a, c) { target.kind.object? ? target.interfaces : nil }
 end

data/lib/graphql/introspection/possible_types_field.rb

@@ -1,5 +1,5 @@
 GraphQL::Introspection::PossibleTypesField = GraphQL::Field.define do
   description "Types which compose this Union or Interface"
-  type -> { types[GraphQL::Introspection::TypeType] }
+  type -> { types[!GraphQL::Introspection::TypeType] }
   resolve -> (target, a, c) { target.kind.resolves? ? target.possible_types : nil }
 end

data/lib/graphql/introspection/type_type.rb

@@ -2,11 +2,11 @@ GraphQL::Introspection::TypeType = GraphQL::ObjectType.define do
   name "__Type"
   description "A type in the GraphQL schema"
 
-  field :name, !types.String,  "The name of this type"
+  field :name, types.String,  "The name of this type"
   field :description, types.String, "What this type represents"
 
   field :kind do
-    type GraphQL::Introspection::TypeKindEnum
+    type !GraphQL::Introspection::TypeKindEnum
     description "The kind of this type"
     resolve -> (target, a, c) { target.kind.name }
   end

data/lib/graphql/list_type.rb

@@ -12,4 +12,8 @@ class GraphQL::ListType < GraphQL::BaseType
   def kind
     GraphQL::TypeKinds::LIST
   end
+
+  def to_s
+    "[#{of_type.to_s}]"
+  end
 end

data/lib/graphql/non_null_type.rb

@@ -20,4 +20,8 @@ class GraphQL::NonNullType < GraphQL::BaseType
   def kind
     GraphQL::TypeKinds::NON_NULL
   end
+
+  def to_s
+    "#{of_type.to_s}!"
+  end
 end

data/lib/graphql/query/arguments.rb

@@ -1,5 +1,3 @@
-require 'forwardable'
-
 # Provide read-only access to arguments by string or symbol names.
 class GraphQL::Query::Arguments
   extend Forwardable

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

@@ -22,6 +22,8 @@ module GraphQL
 
         private
 
+        # After getting the value from the field's resolve method,
+        # continue by "finishing" the value, eg. executing sub-fields or coercing values
         def get_finished_value(raw_value)
           if raw_value.nil?
             nil
@@ -38,20 +40,38 @@ module GraphQL
         end
 
 
+        # Get the result of:
+        # - Any middleware on this schema
+        # - The field's resolve method
         def get_raw_value
-          query.context.ast_node = ast_node
-          value = field.resolve(target, arguments, query.context)
-          query.context.ast_node = nil
-
-          if value == GraphQL::Query::DEFAULT_RESOLVE
-            begin
-              value = target.public_send(ast_node.name)
-            rescue NoMethodError => err
-              raise("Couldn't resolve field '#{ast_node.name}' to #{target.class} '#{target}' (resulted in #{err})")
+          steps = query.schema.middleware + [get_middleware_proc_from_field_resolve]
+          chain = GraphQL::Schema::MiddlewareChain.new(
+            steps: steps,
+            arguments: [parent_type, target, field, arguments, query.context]
+          )
+          chain.call
+        end
+
+
+        # Execute the field's resolve method
+        # then handle the DEFAULT_RESOLVE
+        # @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 = ast_node
+            value = field_definition.resolve(parent_object, field_args, context)
+            context.ast_node = nil
+
+            if value == GraphQL::Query::DEFAULT_RESOLVE
+              begin
+                value = target.public_send(ast_node.name)
+              rescue NoMethodError => err
+                raise("Couldn't resolve field '#{ast_node.name}' to #{parent_object.class} '#{parent_object}' (resulted in #{err})")
+              end
             end
-          end
 
-          value
+            value
+          }
         end
       end
     end

data/lib/graphql/schema.rb

@@ -1,5 +1,7 @@
 # A GraphQL schema which may be queried with {GraphQL::Query}.
 class GraphQL::Schema
+  extend Forwardable
+
   DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
   DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
@@ -7,6 +9,8 @@ class GraphQL::Schema
   # Override these if you don't want the default executor:
   attr_accessor :query_execution_strategy, :mutation_execution_strategy
 
+  # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
+  attr_reader :middleware
 
   # @param query [GraphQL::ObjectType]  the query root for the schema
   # @param mutation [GraphQL::ObjectType, nil] the mutation root for the schema
@@ -15,13 +19,16 @@ class GraphQL::Schema
     @mutation = mutation
     @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]
     # Default to the built-in execution strategy:
     self.query_execution_strategy = GraphQL::Query::SerialExecution
     self.mutation_execution_strategy = GraphQL::Query::SerialExecution
   end
 
-  # A `{ name => type }` hash of types in this schema
-  # @return [Hash]
+  def_delegators :@rescue_middleware, :rescue_from, :remove_handler
+
+  # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
   def types
     @types ||= TypeReducer.find_all([query, mutation, GraphQL::Introspection::SchemaType].compact)
   end
@@ -61,6 +68,8 @@ end
 require 'graphql/schema/each_item_validator'
 require 'graphql/schema/field_validator'
 require 'graphql/schema/implementation_validator'
+require 'graphql/schema/middleware_chain'
+require 'graphql/schema/rescue_middleware'
 require 'graphql/schema/type_reducer'
 require 'graphql/schema/type_map'
 require 'graphql/schema/type_validator'

data/lib/graphql/schema/middleware_chain.rb

@@ -0,0 +1,27 @@
+module GraphQL
+  class Schema
+    # Given {steps} and {arguments}, call steps in order, passing `(*arguments, next_step)`.
+    #
+    # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
+    class MiddlewareChain
+      # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
+      attr_reader :steps
+
+      # @return [Array] Arguments passed to steps (followed by `next_middleware`)
+      attr_reader :arguments
+
+      def initialize(steps:, arguments:)
+        # We're gonna destroy this array, so copy it:
+        @steps = steps.dup
+        @arguments = arguments
+      end
+
+      # Run the next step in the chain, passing in arguments and handle to the next step
+      def call
+        next_step = steps.shift
+        next_middleware = self
+        next_step.call(*arguments, next_middleware)
+      end
+    end
+  end
+end

data/lib/graphql/schema/printer.rb

@@ -0,0 +1,145 @@
+module GraphQL
+  # Used to convert your {GraphQL::Schema} to a GraphQL schema string
+  #
+  # @example print your schema to standard output
+  #   Schema = GraphQL::Schema.new(query: QueryType)
+  #   puts GraphQL::Schema::Printer.print_schema(Schema)
+  #
+  module Schema::Printer
+    extend self
+
+    # Return a GraphQL schema string for the defined types in the schema
+    # @param schema [GraphQL::Schema]
+    def print_schema(schema)
+      print_filtered_schema(schema, method(:is_defined_type))
+    end
+
+    # Return the GraphQL schema string for the introspection type system
+    def print_introspection_schema
+      query_root = ObjectType.define do
+        name "Query"
+      end
+      schema = Schema.new(query: query_root)
+      print_filtered_schema(schema, method(:is_introspection_type))
+    end
+
+    private
+
+    def print_filtered_schema(schema, type_filter)
+      types = schema.types.values.select{ |type| type_filter.call(type) }.sort_by(&:name)
+      types.map{ |type| print_type(type) }.join("\n\n")
+    end
+
+    BUILTIN_SCALARS = Set.new(["String", "Boolean", "Int", "Float", "ID"])
+    private_constant :BUILTIN_SCALARS
+
+    def is_introspection_type(type)
+      type.name.start_with?("__")
+    end
+
+    def is_defined_type(type)
+      !is_introspection_type(type) && !BUILTIN_SCALARS.include?(type.name)
+    end
+
+    def print_type(type)
+      TypeKindPrinters::STRATEGIES.fetch(type.kind).print(type)
+    end
+
+    module TypeKindPrinters
+      module FieldPrinter
+        def print_fields(type)
+          type.fields.values.map{ |field| "  #{field.name}#{print_args(field)}: #{field.type}" }.join("\n")
+        end
+
+        def print_args(field)
+          return if field.arguments.empty?
+          "(#{field.arguments.values.map{ |arg| print_input_value(arg) }.join(", ")})"
+        end
+
+        def print_input_value(arg)
+          default_string = " = #{print_value(arg.default_value, arg.type)}" unless arg.default_value.nil?
+          "#{arg.name}: #{arg.type.to_s}#{default_string}"
+        end
+
+        def print_value(value, type)
+          case type
+          when FLOAT_TYPE
+            value.to_f.inspect
+          when INT_TYPE
+            value.to_i.inspect
+          when BOOLEAN_TYPE
+            (!!value).inspect
+          when ScalarType, ID_TYPE, STRING_TYPE
+            value.to_s.inspect
+          when EnumType
+            value.to_s
+          when InputObjectType
+            fields = value.to_h.map{ |field_name, field_value|
+              field_type = type.input_fields.fetch(field_name.to_s).type
+              "#{field_name}: #{print_value(field_value, field_type)}"
+            }.join(", ")
+            "{ #{fields} }"
+          when NonNullType
+            print_value(value, type.of_type)
+          when ListType
+            "[#{value.to_a.map{ |v| print_value(v, type.of_type) }.join(", ")}]"
+          else
+            raise NotImplementedError, "Unexpected value type #{type.inspect}"
+          end
+        end
+      end
+
+      class ScalarPrinter
+        def self.print(type)
+          "scalar #{type.name}"
+        end
+      end
+
+      class ObjectPrinter
+        extend FieldPrinter
+        def self.print(type)
+          implementations = " implements #{type.interfaces.map(&:to_s).join(", ")}" unless type.interfaces.empty?
+          "type #{type.name}#{implementations} {\n#{print_fields(type)}\n}"
+        end
+      end
+
+      class InterfacePrinter
+        extend FieldPrinter
+        def self.print(type)
+          "interface #{type.name} {\n#{print_fields(type)}\n}"
+        end
+      end
+
+      class UnionPrinter
+        def self.print(type)
+          "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}\n}"
+        end
+      end
+
+      class EnumPrinter
+        def self.print(type)
+          values = type.values.values.map{ |v| "  #{v.name}" }.join("\n")
+          "enum #{type.name} {\n#{values}\n}"
+        end
+      end
+
+      class InputObjectPrinter
+        extend FieldPrinter
+        def self.print(type)
+          fields = type.input_fields.values.map{ |field| "  #{print_input_value(field)}" }.join("\n")
+          "input #{type.name} {\n#{fields}\n}"
+        end
+      end
+
+      STRATEGIES = {
+        GraphQL::TypeKinds::SCALAR =>       ScalarPrinter,
+        GraphQL::TypeKinds::OBJECT =>       ObjectPrinter,
+        GraphQL::TypeKinds::INTERFACE =>    InterfacePrinter,
+        GraphQL::TypeKinds::UNION =>        UnionPrinter,
+        GraphQL::TypeKinds::ENUM =>         EnumPrinter,
+        GraphQL::TypeKinds::INPUT_OBJECT => InputObjectPrinter,
+      }
+    end
+    private_constant :TypeKindPrinters
+  end
+end

data/lib/graphql/schema/rescue_middleware.rb

@@ -0,0 +1,53 @@
+module GraphQL
+  class Schema
+    # - Store a table of errors & handlers
+    # - Rescue errors in a middleware chain, then check for a handler
+    # - If a handler is found, use it & return a {GraphQL::ExecutionError}
+    # - If no handler is found, re-raise the error
+    class RescueMiddleware
+      # @return [Hash] `{class => proc}` pairs for handling errors
+      attr_reader :rescue_table
+      def initialize
+        @rescue_table = {}
+      end
+
+      # @example Rescue from not-found by telling the user
+      #   MySchema.rescue_from(ActiveRecord::NotFound) { "An item could not be found" }
+      #
+      # @param [Class] a class of error to rescue from
+      # @yield [err] A handler to return a message for this error instance
+      # @yieldparam [Exception] an error that was rescued
+      # @yieldreturn [String] message to put in GraphQL response
+      def rescue_from(error_class, &block)
+        rescue_table[error_class] = block
+      end
+
+      # Remove the handler for `error_class`
+      # @param [Class] the error class whose handler should be removed
+      def remove_handler(error_class)
+        rescue_table.delete(error_class)
+      end
+
+      # Implement the requirement for {GraphQL::Schema::MiddlewareChain}
+      def call(*args, next_middleware)
+        begin
+          next_middleware.call
+        rescue StandardError => err
+          attempt_rescue(err)
+        end
+      end
+
+      private
+
+      def attempt_rescue(err)
+        handler = rescue_table[err.class]
+        if handler
+          message = handler.call(err)
+          GraphQL::ExecutionError.new(message)
+        else
+          raise(err)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.9.4"
+  VERSION = "0.9.5"
 end

data/readme.md

@@ -95,11 +95,19 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - Raise if you try to configure an attribute which doesn't suit the type
     - ie, if you try to define `resolve` on an ObjectType, it should somehow raise
   - Incoming enums should be exposed as `EnumValue`s, not `Nodes::Enum`s
+  - Overriding `!` on types breaks ActiveSupport `.blank?`
+
+    ```ruby
+    my_type = GraphQL::ObjectType.define { name("MyType") }
+    # => MyType
+    my_type.present?
+    # => MyType!!
+    my_type.blank?
+    # => MyType!
+    ```
+
 - Big ideas:
   - Use [graphql-parser](https://github.com/shopify/graphql-parser) (Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser)) instead of Parslet
-  - Add instrumentation
-    - Some way to expose what queries are run, what types & fields are accessed, how long things are taking, etc
-    - before-hooks for every field?
 
 ## Goals
 

data/spec/graphql/query/executor_spec.rb

@@ -131,5 +131,30 @@ describe GraphQL::Query::Executor do
         assert_raises(RuntimeError) { result }
       end
     end
+
+    describe "if the schema has a rescue handler" do
+      before do
+        schema.rescue_from(RuntimeError) { "Error was handled!" }
+      end
+
+      after do
+        # remove the handler from the middleware:
+        schema.remove_handler(RuntimeError)
+      end
+
+      it "adds to the errors key" do
+        expected = {
+          "data" => {"error" => nil},
+          "errors"=>[
+            {
+              "message"=>"Error was handled!",
+              "locations" => [{"line"=>1, "column"=>17}]
+            }
+          ]
+        }
+        assert_equal(expected, result)
+      end
+
+    end
   end
 end

data/spec/graphql/schema/middleware_chain_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GraphQL::Schema::MiddlewareChain do
+  let(:step_1) { -> (step_values, next_step) { step_values << 1; next_step.call } }
+  let(:step_2) { -> (step_values, next_step) { step_values << 2; next_step.call } }
+  let(:step_3) { -> (step_values, next_step) { step_values << 3; :return_value } }
+  let(:steps) { [step_1, step_2, step_3] }
+  let(:step_values) { [] }
+  let(:arguments) { [step_values] }
+  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps, arguments: arguments)}
+
+  describe "#call" do
+    it "runs steps in order" do
+      middleware_chain.call
+      assert_equal([1,2,3], step_values)
+    end
+
+    it "returns the value of the last middleware" do
+      assert_equal(:return_value, middleware_chain.call)
+    end
+
+    describe "when a step returns early" do
+      let(:early_return_step) { -> (step_values, next_step) { :early_return } }
+      it "doesn't continue the chain" do
+        steps.insert(2, early_return_step)
+        assert_equal(:early_return, middleware_chain.call)
+        assert_equal([1,2], step_values)
+      end
+    end
+  end
+end

data/spec/graphql/schema/printer_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe GraphQL::Schema::Printer do
+  let(:schema) {
+    node_type = GraphQL::InterfaceType.define do
+      name "Node"
+
+      field :id, !types.ID
+    end
+
+    choice_type = GraphQL::EnumType.define do
+      name "Choice"
+
+      value "FOO"
+      value "BAR"
+    end
+
+    sub_input_type = GraphQL::InputObjectType.define do
+      name "Sub"
+      input_field :string, types.String
+    end
+
+    variant_input_type = GraphQL::InputObjectType.define do
+      name "Varied"
+      input_field :id, types.ID
+      input_field :int, types.Int
+      input_field :float, types.Float
+      input_field :bool, types.Boolean
+      input_field :enum, choice_type
+      input_field :sub, types[sub_input_type]
+    end
+
+    comment_type = GraphQL::ObjectType.define do
+      name "Comment"
+      description "A blog comment"
+      interfaces [node_type]
+
+      field :id, !types.ID
+    end
+
+    post_type = GraphQL::ObjectType.define do
+      name "Post"
+      description "A blog post"
+
+      field :id, !types.ID
+      field :title, !types.String
+      field :body, !types.String
+      field :comments, types[!comment_type]
+    end
+
+    query_root = GraphQL::ObjectType.define do
+      name "Query"
+      description "The query root of this schema"
+
+      field :post do
+        type post_type
+        argument :id, !types.ID
+        argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: "FOO", sub: [{ string: "str" }] }
+        resolve -> (obj, args, ctx) { Post.find(args["id"]) }
+      end
+    end
+
+    GraphQL::Schema.new(query: query_root)
+  }
+
+  describe ".print_introspection_schema" do
+    it "returns the schema as a string for the introspection types" do
+      expected = <<SCHEMA
+type __Directive {
+  name: String!
+  description: String
+  args: [__InputValue!]!
+  onOperation: Boolean!
+  onFragment: Boolean!
+  onField: Boolean!
+}
+
+type __EnumValue {
+  name: String!
+  description: String
+  deprecationReason: String
+  isDeprecated: Boolean!
+}
+
+type __Field {
+  name: String!
+  description: String
+  type: __Type!
+  isDeprecated: Boolean!
+  args: [__InputValue!]!
+  deprecationReason: String
+}
+
+type __InputValue {
+  name: String!
+  description: String
+  type: __Type!
+  defaultValue: String
+}
+
+type __Schema {
+  types: [__Type!]!
+  directives: [__Directive!]!
+  queryType: __Type!
+  mutationType: __Type
+}
+
+type __Type {
+  name: String
+  description: String
+  kind: __TypeKind!
+  fields(includeDeprecated: Boolean = false): [__Field!]
+  ofType: __Type
+  inputFields: [__InputValue!]
+  possibleTypes: [__Type!]
+  enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+  interfaces: [__Type!]
+}
+
+enum __TypeKind {
+  SCALAR
+  OBJECT
+  INTERFACE
+  UNION
+  ENUM
+  INPUT_OBJECT
+  LIST
+  NON_NULL
+}
+SCHEMA
+      assert_equal expected.chomp, GraphQL::Schema::Printer.print_introspection_schema
+    end
+  end
+
+  describe ".print_schema" do
+    it "returns the schema as a string for the defined types" do
+      expected = <<SCHEMA
+enum Choice {
+  FOO
+  BAR
+}
+
+type Comment implements Node {
+  id: ID!
+}
+
+interface Node {
+  id: ID!
+}
+
+type Post {
+  id: ID!
+  title: String!
+  body: String!
+  comments: [Comment!]
+}
+
+type Query {
+  post(id: ID!, varied: Varied = { id: \"123\", int: 234, float: 2.3, enum: FOO, sub: [{ string: \"str\" }] }): Post
+}
+
+input Sub {
+  string: String
+}
+
+input Varied {
+  id: ID
+  int: Int
+  float: Float
+  bool: Boolean
+  enum: Choice
+  sub: [Sub]
+}
+SCHEMA
+      assert_equal expected.chomp, GraphQL::Schema::Printer.print_schema(schema)
+    end
+  end
+end

data/spec/graphql/schema/rescue_middleware_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+class SpecExampleError < StandardError; end
+
+describe GraphQL::Schema::RescueMiddleware do
+  let(:error_middleware) { -> (next_middleware) { raise(error_class) } }
+
+  let(:rescue_middleware) do
+    middleware = GraphQL::Schema::RescueMiddleware.new
+    middleware.rescue_from(SpecExampleError) { |err| "there was an example error: #{err.class.name}" }
+    middleware
+  end
+
+  let(:steps) { [rescue_middleware, error_middleware] }
+
+  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps, arguments: [])}
+
+  describe "known errors" do
+    let(:error_class) { SpecExampleError }
+    it "handles them as execution errors" do
+      result = middleware_chain.call
+      assert_equal("there was an example error: SpecExampleError", result.message)
+      assert_equal(GraphQL::ExecutionError, result.class)
+    end
+  end
+
+  describe "unknown errors" do
+    let(:error_class) { RuntimeError }
+    it "re-raises them" do
+      assert_raises(RuntimeError) { middleware_chain.call }
+    end
+  end
+end

data/spec/graphql/schema_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe GraphQL::Schema do
+  let(:schema) { DummySchema }
+
+  describe "#rescue_from" do
+    let(:rescue_middleware) { schema.middleware.first }
+
+    it "adds handlers to the rescue middleware" do
+      assert_equal(1, rescue_middleware.rescue_table.length)
+      # normally, you'd use a real class, not a symbol:
+      schema.rescue_from(:error_class) { "my custom message" }
+      assert_equal(2, rescue_middleware.rescue_table.length)
+    end
+  end
+end

data/spec/support/dairy_app.rb

@@ -1,5 +1,7 @@
 require_relative './dairy_data'
 
+class NoSuchDairyError < StandardError; end
+
 EdibleInterface = GraphQL::InterfaceType.define do
   name "Edible"
   description "Something you can eat, yum"
@@ -42,7 +44,7 @@ CheeseType = GraphQL::ObjectType.define do
       # get the strings out:
       sources = a["source"].map(&:name)
       if sources.include?("YAK")
-        GraphQL::ExecutionError.new("No cheeses are made from Yak milk!")
+        raise NoSuchDairyError.new("No cheeses are made from Yak milk!")
       else
         CHEESES.values.find { |c| sources.include?(c.source) }
       end
@@ -218,3 +220,4 @@ MutationType = GraphQL::ObjectType.define do
 end
 
 DummySchema = GraphQL::Schema.new(query: QueryType, mutation: MutationType)
+DummySchema.rescue_from(NoSuchDairyError) { |err| err.message  }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-22 00:00:00.000000000 Z
+date: 2015-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -224,6 +224,9 @@ files:
 - lib/graphql/schema/each_item_validator.rb
 - lib/graphql/schema/field_validator.rb
 - lib/graphql/schema/implementation_validator.rb
+- lib/graphql/schema/middleware_chain.rb
+- lib/graphql/schema/printer.rb
+- lib/graphql/schema/rescue_middleware.rb
 - lib/graphql/schema/type_map.rb
 - lib/graphql/schema/type_reducer.rb
 - lib/graphql/schema/type_validator.rb
@@ -275,8 +278,12 @@ files:
 - spec/graphql/query/type_resolver_spec.rb
 - spec/graphql/query_spec.rb
 - spec/graphql/schema/field_validator_spec.rb
+- spec/graphql/schema/middleware_chain_spec.rb
+- spec/graphql/schema/printer_spec.rb
+- spec/graphql/schema/rescue_middleware_spec.rb
 - spec/graphql/schema/type_reducer_spec.rb
 - spec/graphql/schema/type_validator_spec.rb
+- spec/graphql/schema_spec.rb
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb
 - spec/graphql/static_validation/rules/directives_are_defined_spec.rb
@@ -321,7 +328,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A GraphQL implementation for Ruby
@@ -346,8 +353,12 @@ test_files:
 - spec/graphql/query/type_resolver_spec.rb
 - spec/graphql/query_spec.rb
 - spec/graphql/schema/field_validator_spec.rb
+- spec/graphql/schema/middleware_chain_spec.rb
+- spec/graphql/schema/printer_spec.rb
+- spec/graphql/schema/rescue_middleware_spec.rb
 - spec/graphql/schema/type_reducer_spec.rb
 - spec/graphql/schema/type_validator_spec.rb
+- spec/graphql/schema_spec.rb
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb
 - spec/graphql/static_validation/rules/directives_are_defined_spec.rb