graphql 0.7.1 → 0.8.0

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

@@ -12,13 +12,28 @@ module GraphQL
 
         def result
           result_name = ast_node.alias || ast_node.name
-          { result_name => result_value}
+          result_value = get_finished_value(get_raw_value)
+          { result_name => result_value  }
         end
 
         private
 
-        def result_value
+        def get_finished_value(raw_value)
+          if raw_value.nil?
+            nil
+          else
+            resolved_type = field.type.resolve_type(raw_value)
+            strategy_class = GraphQL::Query::BaseExecution::ValueResolution.get_strategy_for_kind(resolved_type.kind)
+            result_strategy = strategy_class.new(raw_value, resolved_type, target, parent_type, ast_node, query, execution_strategy)
+            result_strategy.result
+          end
+        end
+
+
+        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
@@ -28,13 +43,7 @@ module GraphQL
             end
           end
 
-          return nil if value.nil?
-
-
-          resolved_type = field.type.kind.resolve(field.type, value)
-          strategy_class = GraphQL::Query::ValueResolution.get_strategy_for_kind(resolved_type.kind)
-          result_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_node, query, execution_strategy)
-          result_strategy.result
+          value
         end
       end
     end

data/lib/graphql/scalar_type.rb

@@ -1,9 +1,9 @@
 module GraphQL
   # The parent type for scalars, eg {GraphQL::STRING_TYPE}, {GraphQL::INT_TYPE}
   #
-  class ScalarType < GraphQL::ObjectType
-    defined_by_config :name, :coerce
-    attr_accessor :name
+  class ScalarType < GraphQL::BaseType
+    defined_by_config :name, :coerce, :description
+    attr_accessor :name, :description
 
     def coerce(value)
       @coerce_proc.call(value)

data/lib/graphql/schema.rb

@@ -4,6 +4,9 @@ class GraphQL::Schema
   DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
   attr_reader :query, :mutation, :directives, :static_validator
+  # Override these if you don't want the default executors:
+  attr_accessor :query_execution_strategy, :mutation_execution_strategy
+
 
   # @param query [GraphQL::ObjectType]  the query root for the schema
   # @param mutation [GraphQL::ObjectType, nil] the mutation root for the schema
@@ -48,4 +51,5 @@ require 'graphql/schema/each_item_validator'
 require 'graphql/schema/field_validator'
 require 'graphql/schema/implementation_validator'
 require 'graphql/schema/type_reducer'
+require 'graphql/schema/type_map'
 require 'graphql/schema/type_validator'

data/lib/graphql/schema/type_map.rb

@@ -0,0 +1,34 @@
+module GraphQL
+  class Schema
+    # Stores `{ name => type }` pairs for a given schema.
+    # It behaves like a hash except for a couple things:
+    #  - if you use `[key]` and that key isn't defined, 💥!
+    #  - if you try to define the same key twice, 💥!
+    #
+    # 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 initialize
+        @storage = {}
+      end
+
+      def [](key)
+        @storage[key] || raise("No type found for '#{key}'")
+      end
+
+      def []=(key, value)
+        if @storage.key?(key)
+          raise("Duplicate type definition found for name '#{key}'")
+        else
+          @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/type_reducer.rb

@@ -4,25 +4,24 @@ class GraphQL::Schema::TypeReducer
   attr_reader :type, :existing_type_hash
 
   def initialize(type, existing_type_hash)
-    @type = type
+    type = type.nil? ? nil : type.unwrap
+    validate_type(type)
+    if type.respond_to?(:name) && existing_type_hash.fetch(type.name, nil).equal?(type)
+      @result = existing_type_hash
+    else
+      @type = type
+    end
     @existing_type_hash = existing_type_hash
   end
 
   def result
-    @result ||= if type.respond_to?(:kind) && type.kind.wraps?
-      reduce_type(type.of_type, existing_type_hash)
-    elsif type.respond_to?(:name) && existing_type_hash.has_key?(type.name)
-      # been here, done that
-      existing_type_hash
-    else
-      validate_type(type)
-      find_types(type, existing_type_hash.dup)
-    end
+    @result ||= find_types(type, existing_type_hash)
   end
 
   # Reduce all of `types` and return the combined result
   def self.find_all(types)
-    types.reduce({}) do |memo, type|
+    type_map = GraphQL::Schema::TypeMap.new
+    types.reduce(type_map) do |memo, type|
       self.new(type, memo).result
     end
   end
@@ -33,21 +32,20 @@ class GraphQL::Schema::TypeReducer
     type_hash[type.name] = type
     if type.kind.fields?
       type.fields.each do |name, field|
-
-        type_hash.merge!(reduce_type(field.type, type_hash))
+        reduce_type(field.type, type_hash)
         field.arguments.each do |name, argument|
-          type_hash.merge!(reduce_type(argument.type, type_hash))
+          reduce_type(argument.type, type_hash)
         end
       end
     end
     if type.kind.object?
       type.interfaces.each do |interface|
-        type_hash.merge!(reduce_type(interface, type_hash))
+        reduce_type(interface, type_hash)
       end
     end
     if type.kind.resolves?
       type.possible_types.each do |possible_type|
-        type_hash.merge!(reduce_type(possible_type, type_hash))
+        reduce_type(possible_type, type_hash)
       end
     end
     type_hash

data/lib/graphql/static_validation/arguments_validator.rb

@@ -4,14 +4,14 @@ class GraphQL::StaticValidation::ArgumentsValidator
 
   def validate(context)
     visitor = context.visitor
-    visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
-      return if context.skip_field?(node.name)
-      field_defn = context.field_definition
-      validate_node(node, field_defn, context)
-    }
-    visitor[GraphQL::Language::Nodes::Directive] << -> (node, parent) {
-      directive_defn = context.schema.directives[node.name]
-      validate_node(node, directive_defn, context)
+    visitor[GraphQL::Language::Nodes::Argument] << -> (node, parent) {
+      return if parent.is_a?(GraphQL::Language::Nodes::InputObject) || context.skip_field?(parent.name)
+      if parent.is_a?(GraphQL::Language::Nodes::Directive)
+        parent_defn = context.schema.directives[parent.name]
+      else
+        parent_defn = context.field_definition
+      end
+      validate_node(parent, node, parent_defn, context)
     }
   end
 end

data/lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -1,13 +1,11 @@
 class GraphQL::StaticValidation::ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
-  def validate_node(node, defn, context)
-    args_with_literals = node.arguments.select {|a| !a.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)}
+  def validate_node(parent, node, defn, context)
+    return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
     validator = GraphQL::StaticValidation::LiteralValidator.new
-    args_with_literals.each do |arg|
-      arg_defn = defn.arguments[arg.name]
-      valid = validator.validate(arg.value, arg_defn.type)
-      if !valid
-        context.errors << message("Argument #{arg.name} on #{node.class.name.split("::").last} '#{node.name}' has an invalid value", node)
-      end
+    arg_defn = defn.arguments[node.name]
+    valid = validator.validate(node.value, arg_defn.type)
+    if !valid
+      context.errors << message("Argument #{node.name} on #{parent.class.name.split("::").last} '#{parent.name}' has an invalid value", parent)
     end
   end
 end

data/lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -1,15 +1,11 @@
 class GraphQL::StaticValidation::ArgumentsAreDefined < GraphQL::StaticValidation::ArgumentsValidator
-  def validate_node(node, defn, context)
-    skip = nil
-
-    node.arguments.each do |argument|
-      argument_defn = defn.arguments[argument.name]
-      if argument_defn.nil?
-        context.errors << message("#{node.class.name.split("::").last} '#{node.name}' doesn't accept argument #{argument.name}", node)
-        skip = GraphQL::Language::Visitor::SKIP
-      end
+  def validate_node(parent, node, defn, context)
+    argument_defn = defn.arguments[node.name]
+    if argument_defn.nil?
+      context.errors << message("#{parent.class.name.split("::").last} '#{parent.name}' doesn't accept argument #{node.name}", parent)
+      GraphQL::Language::Visitor::SKIP
+    else
+      nil
     end
-
-    skip
   end
 end

data/lib/graphql/static_validation/rules/fields_are_defined_on_type.rb

@@ -8,7 +8,7 @@ class GraphQL::StaticValidation::FieldsAreDefinedOnType
     visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
       return if context.skip_field?(node.name)
       parent_type = context.object_types[-2]
-      parent_type = parent_type.kind.unwrap(parent_type)
+      parent_type = parent_type.unwrap
       validate_field(context.errors, node, parent_type, parent)
     }
   end

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -14,7 +14,7 @@ class GraphQL::StaticValidation::FieldsHaveAppropriateSelections
   private
 
   def validate_field_selections(ast_field, field_defn, errors)
-    resolved_type = field_defn.type.kind.unwrap(field_defn.type)
+    resolved_type = field_defn.type.unwrap
 
     if resolved_type.kind.scalar? && ast_field.selections.any?
       error = message("Selections can't be made on scalars (field '#{ast_field.name}' returns #{resolved_type.name} but has selections [#{ast_field.selections.map(&:name).join(", ")}])", ast_field)

data/lib/graphql/static_validation/rules/fragment_types_exist.rb

@@ -15,7 +15,7 @@ class GraphQL::StaticValidation::FragmentTypesExist
   private
 
   def validate_type_exists(node, context)
-    type = context.schema.types[node.type]
+    type = context.schema.types.fetch(node.type, nil)
     if type.nil?
       context.errors << message("No such type #{node.type}, so it can't be a fragment condition", node)
       GraphQL::Language::Visitor::SKIP

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -1,13 +1,34 @@
-class GraphQL::StaticValidation::RequiredArgumentsArePresent < GraphQL::StaticValidation::ArgumentsValidator
-  def validate_node(node, defn, context)
-    present_argument_names = node.arguments.map(&:name)
+class GraphQL::StaticValidation::RequiredArgumentsArePresent
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    v = context.visitor
+    v[GraphQL::Language::Nodes::Field] << -> (node, parent) { validate_field(node, context) }
+    v[GraphQL::Language::Nodes::Directive] << -> (node, parent) { validate_directive(node, context) }
+  end
+
+  private
+
+  def validate_directive(ast_directive, context)
+    directive_defn = context.schema.directives[ast_directive.name]
+    assert_required_args(ast_directive, directive_defn, context)
+  end
+
+  def validate_field(ast_field, context)
+    return if context.skip_field?(ast_field.name)
+    defn = context.field_definition
+    assert_required_args(ast_field, defn, context)
+  end
+
+  def assert_required_args(ast_node, defn, context)
+    present_argument_names = ast_node.arguments.map(&:name)
     required_argument_names = defn.arguments.values
       .select { |a| a.type.kind.non_null? }
       .map(&:name)
 
     missing_names = required_argument_names - present_argument_names
     if missing_names.any?
-      context.errors << message("#{node.class.name.split("::").last} '#{node.name}' is missing required arguments: #{missing_names.join(", ")}", node)
+      context.errors << message("#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}", ast_node)
     end
   end
 end

data/lib/graphql/static_validation/rules/variable_usages_are_allowed.rb

@@ -32,8 +32,8 @@ class GraphQL::StaticValidation::VariableUsagesAreAllowed
     arg_defn = arguments[arg_node.name]
     arg_defn_type = arg_defn.type
 
-    var_inner_type = var_type.kind.unwrap(var_type)
-    arg_inner_type = arg_defn_type.kind.unwrap(arg_defn_type)
+    var_inner_type = var_type.unwrap
+    arg_inner_type = arg_defn_type.unwrap
 
     if var_inner_type != arg_inner_type
       context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node)

data/lib/graphql/static_validation/type_stack.rb

@@ -48,9 +48,9 @@ class GraphQL::StaticValidation::TypeStack
 
   class FragmentWithTypeStrategy
     def push(stack, node)
-      object_type = stack.schema.types[node.type]
+      object_type = stack.schema.types.fetch(node.type, nil)
       if !object_type.nil?
-        object_type = object_type.kind.unwrap(object_type)
+        object_type = object_type.unwrap
       end
       stack.object_types.push(object_type)
     end
@@ -77,7 +77,7 @@ class GraphQL::StaticValidation::TypeStack
   class FieldStrategy
     def push(stack, node)
       parent_type = stack.object_types.last
-      parent_type = parent_type.kind.unwrap(parent_type)
+      parent_type = parent_type.unwrap
       if parent_type.kind.fields?
         field_class = stack.schema.get_field(parent_type, node.name)
         stack.field_definitions.push(field_class)

data/lib/graphql/type_kinds.rb

@@ -23,25 +23,6 @@ module GraphQL::TypeKinds
     def to_s;       @name;      end
     # Is this TypeKind composed of many values?
     def composite?; @composite; end
-
-    # Get the implementing type for `value` from `type` (no-op for TypeKinds which don't `resolves?`)
-    def resolve(type, value)
-      if resolves?
-        type.resolve_type(value)
-      else
-        type
-      end
-    end
-
-    # Get the modified type for `type` (no-op for TypeKinds which don't `wraps?`)
-    def unwrap(type)
-      if wraps?
-        wrapped_type = type.of_type
-        wrapped_type.kind.unwrap(wrapped_type)
-      else
-        type
-      end
-    end
   end
 
   TYPE_KINDS = [

data/lib/graphql/union_type.rb

@@ -8,22 +8,12 @@
 #     possible_types [DogType, CatType, FishType]
 #   end
 #
-class GraphQL::UnionType
-  include GraphQL::DefinitionHelpers::NonNullWithBang
-  include GraphQL::DefinitionHelpers::DefinedByConfig
-  attr_accessor :name, :description, :possible_types, :resolve_type
+class GraphQL::UnionType < GraphQL::BaseType
+  include GraphQL::BaseType::HasPossibleTypes
+  attr_accessor :name, :description, :possible_types
   defined_by_config :name, :description, :possible_types, :resolve_type
 
   def kind
     GraphQL::TypeKinds::UNION
   end
-
-  # @see {InterfaceType#resolve_type}
-  def resolve_type(object)
-    instance_exec(object, &@resolve_type_proc)
-  end
-
-  def resolve_type=(new_proc)
-    @resolve_type_proc = new_proc || GraphQL::InterfaceType::DEFAULT_RESOLVE_TYPE
-  end
 end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/readme.md

@@ -95,20 +95,9 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - if you were to request a field, then request it in a fragment, it would get looked up twice
   - https://github.com/graphql/graphql-js/issues/19#issuecomment-118515077
 - Code clean-up
-  - Easier built-in type definition
-    - Make an object that accepts type objects, symbols, or corresponding Ruby classes and convertes them to GraphQL types
-    - Hook up that object to `DefinitionConfig`, so it can map from incoming values to GraphQL types
   - 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
-  - Make better inheritance between types
-    - Implement a BaseType (?) and make all type classes extend that
-    - No more extending ObjectType!
-    - Move `TypeKind#unwrap` to BaseType & update all code
-    - Also move `TypeKind#resolve` ?
 - Big ideas:
-  - Cook up some path other than "n+1s everywhere"
-    - See Sangria's `project` approach ([in progress](https://github.com/rmosolgo/graphql-ruby/pull/15))
-    - Try debounced approach?
   - Write Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser) and use that instead of Parslet
   - Add instrumentation
     - Some way to expose what queries are run, what types & fields are accessed, how long things are taking, etc

data/spec/graphql/base_type_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe GraphQL::BaseType do
+  it 'becomes non-null with !' do
+    type = GraphQL::EnumType.new
+    non_null_type = !type
+    assert_equal(GraphQL::TypeKinds::NON_NULL, non_null_type.kind)
+    assert_equal(type, non_null_type.of_type)
+    assert_equal(GraphQL::TypeKinds::NON_NULL, (!GraphQL::STRING_TYPE).kind)
+  end
+
+  it 'can be compared' do
+    assert_equal(!GraphQL::INT_TYPE, !GraphQL::INT_TYPE)
+    refute_equal(!GraphQL::FLOAT_TYPE, GraphQL::FLOAT_TYPE)
+    assert_equal(
+      GraphQL::ListType.new(of_type: MilkType),
+      GraphQL::ListType.new(of_type: MilkType)
+    )
+    refute_equal(
+      GraphQL::ListType.new(of_type: MilkType),
+      GraphQL::ListType.new(of_type: !MilkType)
+    )
+  end
+end