graphql 0.12.1 → 0.13.0

data/lib/graphql/schema.rb

@@ -1,93 +1,103 @@
-# A GraphQL schema which may be queried with {GraphQL::Query}.
-class GraphQL::Schema
-  extend Forwardable
+module GraphQL
+  # A GraphQL schema which may be queried with {GraphQL::Query}.
+  class Schema
+    extend Forwardable
 
-  DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
-  DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
+    DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
+    DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
-  attr_reader :query, :mutation, :subscription, :directives, :static_validator
-  attr_accessor :max_depth
-  # Override these if you don't want the default executor:
-  attr_accessor :query_execution_strategy,
-    :mutation_execution_strategy,
-    :subscription_execution_strategy
+    attr_reader :query, :mutation, :subscription, :directives, :static_validator
+    attr_accessor :max_depth
+    # Override these if you don't want the default executor:
+    attr_accessor :query_execution_strategy,
+      :mutation_execution_strategy,
+      :subscription_execution_strategy
 
-  # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
-  attr_reader :middleware
+    # @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] the mutation root for the schema
-  # @param subscription [GraphQL::ObjectType] the subscription root for the schema
-  # @param max_depth [Integer] maximum query nesting (if it's greater, raise an error)
-  # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
-  def initialize(query:, mutation: nil, subscription: nil, max_depth: nil, types: [])
-    @query    = query
-    @mutation = mutation
-    @subscription = subscription
-    @max_depth = max_depth
-    @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]
-    # Default to the built-in execution strategy:
-    self.query_execution_strategy = GraphQL::Query::SerialExecution
-    self.mutation_execution_strategy = GraphQL::Query::SerialExecution
-    self.subscription_execution_strategy = GraphQL::Query::SerialExecution
-  end
+    # @param query [GraphQL::ObjectType]  the query root for the schema
+    # @param mutation [GraphQL::ObjectType] the mutation root for the schema
+    # @param subscription [GraphQL::ObjectType] the subscription root for the schema
+    # @param max_depth [Integer] maximum query nesting (if it's greater, raise an error)
+    # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
+    def initialize(query:, mutation: nil, subscription: nil, max_depth: nil, types: [])
+      @query    = query
+      @mutation = mutation
+      @subscription = subscription
+      @max_depth = max_depth
+      @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]
+      # Default to the built-in execution strategy:
+      self.query_execution_strategy = GraphQL::Query::SerialExecution
+      self.mutation_execution_strategy = GraphQL::Query::SerialExecution
+      self.subscription_execution_strategy = GraphQL::Query::SerialExecution
+    end
 
-  def_delegators :@rescue_middleware, :rescue_from, :remove_handler
+    def_delegators :@rescue_middleware, :rescue_from, :remove_handler
 
-  # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
-  def types
-    @types ||= begin
-      all_types = @orphan_types + [query, mutation, GraphQL::Introspection::SchemaType]
-      TypeReducer.find_all(all_types.compact)
+    # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
+    def types
+      @types ||= begin
+        all_types = @orphan_types + [query, mutation, GraphQL::Introspection::SchemaType]
+        TypeReducer.find_all(all_types.compact)
+      end
     end
-  end
 
-  # Execute a query on itself.
-  # See {Query#initialize} for arguments.
-  # @return [Hash] query result, ready to be serialized as JSON
-  def execute(*args)
-    query = GraphQL::Query.new(self, *args)
-    query.result
-  end
+    # Execute a query on itself.
+    # See {Query#initialize} for arguments.
+    # @return [Hash] query result, ready to be serialized as JSON
+    def execute(*args)
+      query = GraphQL::Query.new(self, *args)
+      query.result
+    end
 
-  # Resolve field named `field_name` for type `parent_type`.
-  # Handles dynamic fields `__typename`, `__type` and `__schema`, too
-  def get_field(parent_type, field_name)
-    defined_field = parent_type.get_field(field_name)
-    if defined_field
-      defined_field
-    elsif field_name == "__typename"
-      GraphQL::Introspection::TypenameField.create(parent_type)
-    elsif field_name == "__schema" && parent_type == query
-      GraphQL::Introspection::SchemaField.create(self)
-    elsif field_name == "__type" && parent_type == query
-      GraphQL::Introspection::TypeByNameField.create(self.types)
-    else
-      nil
+    # Resolve field named `field_name` for type `parent_type`.
+    # Handles dynamic fields `__typename`, `__type` and `__schema`, too
+    def get_field(parent_type, field_name)
+      defined_field = parent_type.get_field(field_name)
+      if defined_field
+        defined_field
+      elsif field_name == "__typename"
+        GraphQL::Introspection::TypenameField.create(parent_type)
+      elsif field_name == "__schema" && parent_type == query
+        GraphQL::Introspection::SchemaField.create(self)
+      elsif field_name == "__type" && parent_type == query
+        GraphQL::Introspection::TypeByNameField.create(self.types)
+      else
+        nil
+      end
     end
-  end
 
-  def type_from_ast(ast_node)
-    GraphQL::Schema::TypeExpression.new(self, ast_node).type
-  end
+    def type_from_ast(ast_node)
+      GraphQL::Schema::TypeExpression.new(self, ast_node).type
+    end
+
+    # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
+    # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
+    def possible_types(type_defn)
+      @interface_possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
+      @interface_possible_types.possible_types(type_defn)
+    end
 
-  class InvalidTypeError < GraphQL::Error
-    def initialize(type, errors)
-      super("Type #{type.respond_to?(:name) ? type.name :  "Unnamed type" } is invalid: #{errors.join(", ")}")
+    class InvalidTypeError < GraphQL::Error
+      def initialize(type, name)
+        super("#{name} has an invalid type: must be an instance of GraphQL::BaseType, not #{type.class.inspect} (#{type.inspect})")
+      end
     end
   end
 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_expression'
-require 'graphql/schema/type_reducer'
-require 'graphql/schema/type_map'
-require 'graphql/schema/type_validator'
+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/possible_types"
+require "graphql/schema/type_expression"
+require "graphql/schema/type_reducer"
+require "graphql/schema/type_map"
+require "graphql/schema/type_validator"

data/lib/graphql/schema/each_item_validator.rb

@@ -1,16 +1,20 @@
-class GraphQL::Schema::EachItemValidator
-  def initialize(errors)
-    @errors = errors
-  end
+module GraphQL
+  class Schema
+    class EachItemValidator
+      def initialize(errors)
+        @errors = errors
+      end
 
-  def validate(items, as:, must_be:)
-    if !items.is_a?(Array)
-      @errors << "#{as} must be an Array, not #{items.inspect}"
-      return
-    else
-      invalid_items = items.select {|k| !yield(k) }
-      if invalid_items.any?
-        @errors << "#{as} must be #{must_be}, but some aren't: #{invalid_items.map(&:to_s).join(", ")}"
+      def validate(items, as:, must_be:)
+        if !items.is_a?(Array)
+          @errors << "#{as} must be an Array, not #{items.inspect}"
+          return
+        else
+          invalid_items = items.select {|k| !yield(k) }
+          if invalid_items.any?
+            @errors << "#{as} must be #{must_be}, but some aren't: #{invalid_items.map(&:to_s).join(", ")}"
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/field_validator.rb

@@ -1,13 +1,17 @@
-class GraphQL::Schema::FieldValidator
-  def validate(field, errors)
-    implementation = GraphQL::Schema::ImplementationValidator.new(field, as: "Field", errors: errors)
-    implementation.must_respond_to(:name)
-    implementation.must_respond_to(:type)
-    implementation.must_respond_to(:description)
-    implementation.must_respond_to(:arguments) do |arguments|
-      validator = GraphQL::Schema::EachItemValidator.new(errors)
-      validator.validate(arguments.keys, as: "#{field.name}.arguments keys", must_be: "Strings") { |k| k.is_a?(String) }
+module GraphQL
+  class Schema
+    class FieldValidator
+      def validate(field, errors)
+        implementation = GraphQL::Schema::ImplementationValidator.new(field, as: "Field", errors: errors)
+        implementation.must_respond_to(:name)
+        implementation.must_respond_to(:type)
+        implementation.must_respond_to(:description)
+        implementation.must_respond_to(:arguments) do |arguments|
+          validator = GraphQL::Schema::EachItemValidator.new(errors)
+          validator.validate(arguments.keys, as: "#{field.name}.arguments keys", must_be: "Strings") { |k| k.is_a?(String) }
+        end
+        implementation.must_respond_to(:deprecation_reason)
+      end
     end
-    implementation.must_respond_to(:deprecation_reason)
   end
 end

data/lib/graphql/schema/implementation_validator.rb

@@ -1,26 +1,30 @@
-# A helper to ensure `object` implements the concept `as`
-class GraphQL::Schema::ImplementationValidator
-  attr_reader :object, :errors, :implementation_as
-  def initialize(object, as:, errors:)
-    @object = object
-    @implementation_as = as
-    @errors = errors
-  end
+module GraphQL
+  class Schema
+    # A helper to ensure `object` implements the concept `as`
+    class ImplementationValidator
+      attr_reader :object, :errors, :implementation_as
+      def initialize(object, as:, errors:)
+        @object = object
+        @implementation_as = as
+        @errors = errors
+      end
 
-  # Ensure the object responds to `method_name`.
-  # If `block_given?`, yield the return value of that method
-  # If provided, use `as` in the error message, overriding class-level `as`.
-  def must_respond_to(method_name, args: [], as: nil)
-    local_as = as || implementation_as
-    method_signature = "##{method_name}(#{args.join(", ")})"
-    if !object.respond_to?(method_name)
-      errors << "#{object.to_s} must respond to #{method_signature} to be a #{local_as}"
-    elsif block_given?
-      return_value = object.public_send(method_name)
-      if return_value.nil?
-        errors << "#{object.to_s} must return a value for #{method_signature} to be a #{local_as}"
-      else
-        yield(return_value)
+      # Ensure the object responds to `method_name`.
+      # If `block_given?`, yield the return value of that method
+      # If provided, use `as` in the error message, overriding class-level `as`.
+      def must_respond_to(method_name, args: [], as: nil)
+        local_as = as || implementation_as
+        method_signature = "##{method_name}(#{args.join(", ")})"
+        if !object.respond_to?(method_name)
+          errors << "#{object.to_s} must respond to #{method_signature} to be a #{local_as}"
+        elsif block_given?
+          return_value = object.public_send(method_name)
+          if return_value.nil?
+            errors << "#{object.to_s} must return a value for #{method_signature} to be a #{local_as}"
+          else
+            yield(return_value)
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/middleware_chain.rb

@@ -17,7 +17,8 @@ module GraphQL
       end
 
       # Run the next step in the chain, passing in arguments and handle to the next step
-      def call
+      def call(next_arguments = @arguments)
+        @arguments = next_arguments
         next_step = steps.shift
         next_middleware = self
         next_step.call(*arguments, next_middleware)

data/lib/graphql/schema/possible_types.rb

@@ -0,0 +1,34 @@
+module GraphQL
+  class Schema
+    # Find the members of a union or interface within a given schema.
+    #
+    # (Although its members never change, unions are handled this way to simplify execution code.)
+    #
+    # Internally, the calculation is cached. It's assumed that schema members _don't_ change after creating the schema!
+    #
+    # @example Get an interface's possible types
+    #   possible_types = GraphQL::Schema::PossibleTypes(MySchema)
+    #   possible_types.possible_types(MyInterface)
+    #   # => [MyObjectType, MyOtherObjectType]
+    class PossibleTypes
+      def initialize(schema)
+        @object_types = schema.types.values.select { |type| type.kind.object? }
+
+        @storage = Hash.new do |hash, key|
+          hash[key] = @object_types.select { |type| type.interfaces.include?(key) }.sort_by(&:name)
+        end
+      end
+
+      def possible_types(type_defn)
+        case type_defn
+        when GraphQL::UnionType
+          type_defn.possible_types
+        when GraphQL::InterfaceType
+          @storage[type_defn]
+        else
+          raise "#{type_defn} doesn't have possible types"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/printer.rb

@@ -1,154 +1,156 @@
 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
+  class Schema
+    # 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 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"
+      # 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
-      schema = Schema.new(query: query_root)
-      print_filtered_schema(schema, method(:is_introspection_type))
-    end
 
-    private
+      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
+      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
+      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_introspection_type(type)
+        type.name.start_with?("__")
+      end
 
-    def is_defined_type(type)
-      !is_introspection_type(type) && !BUILTIN_SCALARS.include?(type.name)
-    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
+      def print_type(type)
+        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(type)
+      end
 
-    module TypeKindPrinters
-      module FieldPrinter
-        def print_fields(type)
-          type.all_fields.map{ |field| "  #{field.name}#{print_args(field)}: #{field.type}" }.join("\n")
-        end
+      module TypeKindPrinters
+        module FieldPrinter
+          def print_fields(type)
+            type.all_fields.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_args(field)
+            return if field.arguments.empty?
+            "(#{field.arguments.values.map{ |arg| print_input_value(arg) }.join(", ")})"
+          end
+
+          def print_input_value(arg)
+            if arg.default_value.nil?
+              default_string = nil
+            else
+              default_string = " = #{print_value(arg.default_value, arg.type)}"
+            end
 
-        def print_input_value(arg)
-          if arg.default_value.nil?
-            default_string = nil
-          else
-            default_string = " = #{print_value(arg.default_value, arg.type)}"
+            "#{arg.name}: #{arg.type.to_s}#{default_string}"
           end
 
-          "#{arg.name}: #{arg.type.to_s}#{default_string}"
+          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
 
-        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}"
+        class ScalarPrinter
+          def self.print(type)
+            "scalar #{type.name}"
           end
         end
-      end
 
-      class ScalarPrinter
-        def self.print(type)
-          "scalar #{type.name}"
+        class ObjectPrinter
+          extend FieldPrinter
+          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}"
+          end
         end
-      end
 
-      class ObjectPrinter
-        extend FieldPrinter
-        def self.print(type)
-          if type.interfaces.any?
-            implementations = " implements #{type.interfaces.map(&:to_s).join(", ")}"
-          else
-            implementations = nil
+        class InterfacePrinter
+          extend FieldPrinter
+          def self.print(type)
+            "interface #{type.name} {\n#{print_fields(type)}\n}"
           end
-          "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}"
+        class UnionPrinter
+          def self.print(type)
+            "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}\n}"
+          end
         end
-      end
 
-      class UnionPrinter
-        def self.print(type)
-          "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}\n}"
+        class EnumPrinter
+          def self.print(type)
+            values = type.values.values.map{ |v| "  #{v.name}" }.join("\n")
+            "enum #{type.name} {\n#{values}\n}"
+          end
         end
-      end
 
-      class EnumPrinter
-        def self.print(type)
-          values = type.values.values.map{ |v| "  #{v.name}" }.join("\n")
-          "enum #{type.name} {\n#{values}\n}"
+        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
-      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
+        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
-
-      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,
-      }
+      private_constant :TypeKindPrinters
     end
-    private_constant :TypeKindPrinters
   end
 end