graphql 0.13.0 → 0.14.0

data/lib/graphql/language/parser.y

@@ -108,11 +108,14 @@ rule
           }
 
   name:
+      name_without_on
+    | ON
+
+  name_without_on:
       IDENTIFIER
     | FRAGMENT
     | TRUE
     | FALSE
-    | ON
 
   arguments_opt:
       /* none */                    { return [] }
@@ -171,7 +174,7 @@ rule
   directive: DIR_SIGN name arguments_opt { return make_node(:Directive, name: val[1], arguments: val[2], position_source: val[0]) }
 
   fragment_spread:
-      ELLIPSIS name directives_list_opt { return make_node(:FragmentSpread, name: val[1], directives: val[2], position_source: val[0]) }
+      ELLIPSIS name_without_on directives_list_opt { return make_node(:FragmentSpread, name: val[1], directives: val[2], position_source: val[0]) }
 
   inline_fragment:
       ELLIPSIS ON name directives_list_opt selection_set {
@@ -192,7 +195,7 @@ rule
       }
 
   fragment_definition:
-    FRAGMENT name ON name directives_list_opt selection_set {
+    FRAGMENT name ON name_without_on directives_list_opt selection_set {
       return make_node(:FragmentDefinition, {
           name:       val[1],
           type:       val[3],
@@ -248,7 +251,11 @@ def on_error(parser_token_id, lexer_token, vstack)
       raise GraphQL::ParseError.new("Parse Error on unknown token: {token_id: #{parser_token_id}, lexer_token: #{lexer_token}} from #{@query_string}", nil, nil, @query_string)
     else
       line, col = lexer_token.line_and_column
-      raise GraphQL::ParseError.new("Parse error on #{lexer_token.to_s.inspect} (#{parser_token_name}) at [#{line}, #{col}]", line, col, @query_string)
+      if lexer_token.name == :BAD_UNICODE_ESCAPE
+        raise GraphQL::ParseError.new("Parse error on bad Unicode escape sequence: #{lexer_token.to_s.inspect} (#{parser_token_name}) at [#{line}, #{col}]", line, col, @query_string)
+      else
+        raise GraphQL::ParseError.new("Parse error on #{lexer_token.to_s.inspect} (#{parser_token_name}) at [#{line}, #{col}]", line, col, @query_string)
+      end
     end
   end
 end

data/lib/graphql/object_type.rb

@@ -59,5 +59,26 @@ module GraphQL
         memo.merge!(iface.fields)
       end
     end
+
+
+    # Error raised when the value provided for a field can't be resolved to one of the possible types
+    # for the field.
+    class UnresolvedTypeError < GraphQL::Error
+      attr_reader :field_name, :field_type, :parent_type
+
+      def initialize(field_name, field_type, parent_type)
+        @field_name = field_name
+        @field_type = field_type
+        @parent_type = parent_type
+        super(exception_message)
+      end
+
+      private
+
+      def exception_message
+        "The value returned for field #{field_name} on #{parent_type} could not be resolved "\
+        "to one of the possible types for #{field_type}."
+      end
+    end
   end
 end

data/lib/graphql/query.rb

@@ -8,7 +8,7 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :document, :context, :fragments, :operations, :debug, :max_depth
+    attr_reader :schema, :document, :context, :fragments, :operations, :debug, :root_value, :max_depth
 
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
@@ -18,17 +18,22 @@ module GraphQL
     # @param debug [Boolean] if true, errors are raised, if false, errors are put in the `errors` key
     # @param validate [Boolean] if true, `query_string` will be validated with {StaticValidation::Validator}
     # @param operation_name [String] if the query string contains many operations, this is the one which should be executed
-    def initialize(schema, query_string, context: nil, variables: {}, debug: false, validate: true, operation_name: nil, max_depth: nil)
+    # @param root_value [Object] the object used to resolve fields on the root type
+    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, debug: false, validate: true, operation_name: nil, root_value: nil, max_depth: nil)
+      fail ArgumentError, "a query string or document is required" unless query_string || document
+
       @schema = schema
       @debug = debug
       @max_depth = max_depth || schema.max_depth
       @context = Context.new(query: self, values: context)
+      @root_value = root_value
       @validate = validate
       @operation_name = operation_name
       @fragments = {}
       @operations = {}
       @provided_variables = variables
-      @document = GraphQL.parse(query_string)
+
+      @document = document || GraphQL.parse(query_string)
       @document.definitions.each do |part|
         if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
           @fragments[part.name] = part

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

@@ -2,7 +2,7 @@ module GraphQL
   class Query
     class SerialExecution
       class OperationResolution
-        attr_reader :query, :target, :ast_operation_definition, :execution_context
+        attr_reader :target, :ast_operation_definition, :execution_context
 
         def initialize(ast_operation_definition, target, execution_context)
           @ast_operation_definition = ast_operation_definition
@@ -13,7 +13,7 @@ module GraphQL
         def result
           selections = ast_operation_definition.selections
           execution_context.strategy.selection_resolution.new(
-            nil,
+            execution_context.query.root_value,
             target,
             selections,
             execution_context

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

@@ -55,6 +55,11 @@ module GraphQL
         class HasPossibleTypeResolution < BaseResolution
           def non_null_result
             resolved_type = field_type.resolve_type(value, execution_context)
+
+            unless resolved_type.is_a?(GraphQL::ObjectType)
+              raise GraphQL::ObjectType::UnresolvedTypeError.new(ast_field.name, field_type, parent_type)
+            end
+
             strategy_class = get_strategy_for_kind(resolved_type.kind)
             inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, execution_context)
             inner_strategy.result

data/lib/graphql/schema.rb

@@ -1,3 +1,12 @@
+require "graphql/schema/invalid_type_error"
+require "graphql/schema/middleware_chain"
+require "graphql/schema/rescue_middleware"
+require "graphql/schema/possible_types"
+require "graphql/schema/reduce_types"
+require "graphql/schema/type_expression"
+require "graphql/schema/type_map"
+require "graphql/schema/validation"
+
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
   class Schema
@@ -43,7 +52,7 @@ module GraphQL
     def types
       @types ||= begin
         all_types = @orphan_types + [query, mutation, GraphQL::Introspection::SchemaType]
-        TypeReducer.find_all(all_types.compact)
+        GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
       end
     end
 
@@ -73,7 +82,7 @@ module GraphQL
     end
 
     def type_from_ast(ast_node)
-      GraphQL::Schema::TypeExpression.new(self, ast_node).type
+      GraphQL::Schema::TypeExpression.build_type(self, ast_node)
     end
 
     # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
@@ -82,22 +91,5 @@ module GraphQL
       @interface_possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
       @interface_possible_types.possible_types(type_defn)
     end
-
-    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/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/invalid_type_error.rb

@@ -0,0 +1,6 @@
+module GraphQL
+  class Schema
+    class InvalidTypeError < GraphQL::Error
+    end
+  end
+end

data/lib/graphql/schema/reduce_types.rb

@@ -0,0 +1,68 @@
+module GraphQL
+  class Schema
+    module ReduceTypes
+      # @param types [Array<GraphQL::BaseType>] members of a schema to crawl for all member types
+      # @return [GraphQL::Schema::TypeMap] `{name => Type}` pairs derived from `types`
+      def self.reduce(types)
+        type_map = GraphQL::Schema::TypeMap.new
+        types.each do |type|
+          reduce_type(type, type_map, type.name)
+        end
+        type_map
+      end
+
+      private
+
+      # Based on `type`, add members to `type_hash`.
+      # If `type` has already been visited, just return the `type_hash` as-is
+      def self.reduce_type(type, type_hash, context_description)
+        if !type.is_a?(GraphQL::BaseType)
+          message = "#{context_description} has an invalid type: must be an instance of GraphQL::BaseType, not #{type.class.inspect} (#{type.inspect})"
+          raise GraphQL::Schema::InvalidTypeError.new(message)
+        end
+
+        type = type.unwrap
+
+        # Don't re-visit a type
+        if !type_hash.fetch(type.name, nil).equal?(type)
+          validate_type(type, context_description)
+          type_hash[type.name] = type
+          crawl_type(type, type_hash, context_description)
+        end
+      end
+
+      def self.crawl_type(type, type_hash, context_description)
+        if type.kind.fields?
+          type.all_fields.each do |field|
+            reduce_type(field.type, type_hash, "Field #{type.name}.#{field.name}")
+            field.arguments.each do |name, argument|
+              reduce_type(argument.type, type_hash, "Argument #{name} on #{type.name}.#{field.name}")
+            end
+          end
+        end
+        if type.kind.object?
+          type.interfaces.each do |interface|
+            reduce_type(interface, type_hash, "Interface on #{type.name}")
+          end
+        end
+        if type.kind.union?
+          type.possible_types.each do |possible_type|
+            reduce_type(possible_type, type_hash, "Possible type for #{type.name}")
+          end
+        end
+        if type.kind.input_object?
+          type.arguments.each do |argument_name, argument|
+            reduce_type(argument.type, type_hash, "Input field #{type.name}.#{argument_name}")
+          end
+        end
+      end
+
+      def self.validate_type(type, context_description)
+        error_message = GraphQL::Schema::Validation.validate(type)
+        if error_message
+          raise GraphQL::Schema::InvalidTypeError.new("#{context_description} is invalid: #{error_message}")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/type_expression.rb

@@ -1,25 +1,15 @@
 module GraphQL
   class Schema
-    class TypeExpression
-      def initialize(schema, ast_node)
-        @schema = schema
-        @ast_node = ast_node
-      end
-
-      def type
-        @type ||= build_type(@schema, @ast_node)
-      end
-
-      private
-
-      def build_type(schema, ast_node)
-        if ast_node.is_a?(GraphQL::Language::Nodes::TypeName)
+    module TypeExpression
+      def self.build_type(schema, ast_node)
+        case ast_node
+        when GraphQL::Language::Nodes::TypeName
           type_name = ast_node.name
           schema.types[type_name]
-        elsif ast_node.is_a?(GraphQL::Language::Nodes::NonNullType)
+        when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
           build_type(schema, ast_inner_type).to_non_null_type
-        elsif ast_node.is_a?(GraphQL::Language::Nodes::ListType)
+        when GraphQL::Language::Nodes::ListType
           ast_inner_type = ast_node.of_type
           build_type(schema, ast_inner_type).to_list_type
         end

data/lib/graphql/schema/type_map.rb

@@ -8,7 +8,7 @@ module GraphQL
     # If you want a type, but want to handle the undefined case, use {#fetch}.
     class TypeMap
       extend Forwardable
-      def_delegators :@storage, :key?, :keys, :values
+      def_delegators :@storage, :key?, :keys, :values, :to_h, :fetch
 
       def initialize
         @storage = {}
@@ -25,10 +25,6 @@ module GraphQL
           @storage[key] = value
         end
       end
-
-      def fetch(key, fallback_value)
-        @storage.key?(key) ? @storage[key] : fallback_value
-      end
     end
   end
 end

data/lib/graphql/schema/validation.rb

@@ -0,0 +1,164 @@
+module GraphQL
+  class Schema
+    # This module provides a function for validating GraphQL types.
+    #
+    # Its {RULES} contain objects that respond to `#call(type)`. Rules are
+    # looked up for given types (by class ancestry), then applied to
+    # the object until an error is returned.
+    class Validation
+      # Lookup the rules for `object` based on its class,
+      # Then returns an error message or `nil`
+      # @param object [Object] something to be validated
+      # @return [String, Nil] error message, if there was one
+      def self.validate(object)
+        rules = RULES.reduce([]) do |memo, (parent_class, validations)|
+          memo + (object.is_a?(parent_class) ? validations : [])
+        end
+        # Stops after the first error
+        rules.reduce(nil) { |memo, rule| memo || rule.call(object) }
+      end
+
+      module Rules
+        # @param property_name [Symbol] The method to validate
+        # @param allowed_classes [Class] Classes which the return value may be an instance of
+        # @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) {
+            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})"
+          }
+        end
+
+        # @param property_name [Symbol] The method whose return value will be validated
+        # @param from_class [Class] The class for keys in the return value
+        # @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) {
+            property_value = obj.public_send(property_name)
+            error_message = nil
+            if !property_value.is_a?(Hash)
+              "#{property_name} must be a hash of {#{from_class.name} => #{to_class.name}}, not a #{property_value.class.name} (#{property_value.inspect})"
+            else
+              invalid_key, invalid_value = property_value.find { |key, value| !key.is_a?(from_class) || !value.is_a?(to_class) }
+              if invalid_key
+                "#{property_name} must map #{from_class} => #{to_class}, not #{invalid_key.class.name} => #{invalid_value.class.name} (#{invalid_key.inspect} => #{invalid_value.inspect})"
+              else
+                nil # OK
+              end
+            end
+          }
+        end
+
+        # @param property_name [Symbol] The method whose return value will be validated
+        # @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) {
+            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})"
+            else
+              invalid_member = property_value.find { |value| !value.is_a?(list_member_class) }
+              if invalid_member
+                "#{property_name} must contain #{list_member_class.name}, not #{invalid_member.class.name} (#{invalid_member.inspect})"
+              else
+                nil # OK
+              end
+            end
+          }
+        end
+
+        def self.assert_named_items_are_valid(item_name, get_items_proc)
+          -> (type) {
+            items = get_items_proc.call(type)
+            error_message = nil
+            items.each do |item|
+              item_message = GraphQL::Schema::Validation.validate(item)
+              if item_message
+                error_message = "#{item_name} #{item.name.inspect} #{item_message}"
+                break
+              end
+            end
+            error_message
+          }
+        end
+
+
+        FIELDS_ARE_VALID = Rules.assert_named_items_are_valid("field", -> (type) { type.all_fields })
+
+        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 })
+
+        DEFAULT_VALUE_IS_VALID_FOR_TYPE = -> (type) {
+          if !type.default_value.nil?
+            coerced_value = type.type.coerce_input(type.default_value)
+            if coerced_value.nil?
+              "default value #{type.default_value.inspect} is not valid for type #{type.type}"
+            end
+          end
+        }
+
+        TYPE_IS_VALID_INPUT_TYPE = -> (type) {
+          outer_type = type.type
+          inner_type = outer_type.is_a?(GraphQL::BaseType) ? outer_type.unwrap : nil
+
+          case inner_type
+          when GraphQL::ScalarType, GraphQL::InputObjectType, GraphQL::EnumType
+            # OK
+          else
+            "type must be a valid input type (Scalar or InputObject), not #{outer_type.class} (#{outer_type})"
+          end
+        }
+      end
+
+      # A mapping of `{Class => [Proc, Proc...]}` pairs.
+      # To validate an instance, find entries where `object.is_a?(key)` is true.
+      # Then apply each rule from the matching values.
+      RULES = {
+        GraphQL::Field => [
+          Rules::NAME_IS_STRING,
+          Rules::DESCRIPTION_IS_STRING_OR_NIL,
+          Rules.assert_property(:deprecation_reason, String, NilClass),
+          Rules.assert_property(:type, GraphQL::BaseType),
+          Rules.assert_property(:property, Symbol, NilClass),
+          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
+          Rules::ARGUMENTS_ARE_VALID,
+        ],
+        GraphQL::Argument => [
+          Rules::NAME_IS_STRING,
+          Rules::DESCRIPTION_IS_STRING_OR_NIL,
+          Rules::TYPE_IS_VALID_INPUT_TYPE,
+          Rules::DEFAULT_VALUE_IS_VALID_FOR_TYPE,
+        ],
+        GraphQL::BaseType => [
+          Rules::NAME_IS_STRING,
+          Rules::DESCRIPTION_IS_STRING_OR_NIL,
+        ],
+        GraphQL::ObjectType => [
+          Rules.assert_property_list_of(:interfaces, GraphQL::InterfaceType),
+          Rules::FIELDS_ARE_VALID,
+        ],
+        GraphQL::InputObjectType => [
+          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
+          Rules::ARGUMENTS_ARE_VALID,
+        ],
+        GraphQL::UnionType => [
+          Rules.assert_property_list_of(:possible_types, GraphQL::ObjectType),
+          Rules::HAS_ONE_OR_MORE_POSSIBLE_TYPES,
+        ],
+        GraphQL::InterfaceType => [
+          Rules::FIELDS_ARE_VALID,
+        ],
+      }
+    end
+  end
+end