graphql 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45c3f35aae5e941e7bad2109eb9405e6afc081cc
-  data.tar.gz: 3cd3d8dd85a88e341552d0709aff11361937d157
+  metadata.gz: 9cf6add0a41fbbf194c90bd12da917467ae612d7
+  data.tar.gz: b0e7b7f03eb0e6a9def2f7402f3349e69d07ec33
 SHA512:
-  metadata.gz: 274f08f78112de84f94dcb9fcdcc62da63a36a29000aad2055cf5e353327bb9ba3f673fe3e83c3a3c6405b360847f17104ab97c66a08323400f6df3f27f6044a
-  data.tar.gz: 82f47b290d9779b1214bb59857edb079369932d08686a8ac1af47c15ab1f3e549e4c8f9f269947836fe2093fc49badc6986e397466cb2d1010520bc3a765e7ff
+  metadata.gz: f5d0f097d277cdd8e40976ce87ef5d57edf365c2fadf821de5c90d7dad9f9d7819a21291c6b01a83ab05e1d7850617bbbe0382c492776b04e5fa619e186e8caa
+  data.tar.gz: ee252ea72993ee9c07ce9d69f6f25c0b6d13e9f7f2bf7cbbb419d8d2b01f48a9c7e57310c6cc05e051c833ee72b42494399bd5252813a4641d1ba3e88be17d16

data/lib/graph_ql/definition_helpers/definable.rb

@@ -0,0 +1,18 @@
+# Define attributes which can be assigned & read, or
+# "defined", by passing the new value as an argument
+#
+# @example defining an object's name
+#   object.name("New name")
+#
+module GraphQL::Definable
+  def attr_definable(*names)
+    attr_accessor(*names)
+    names.each do |name|
+      ivar_name = "@#{name}".to_sym
+      define_method(name) do |new_value=nil|
+        new_value && self.instance_variable_set(ivar_name, new_value)
+        instance_variable_get(ivar_name)
+      end
+    end
+  end
+end

data/lib/graph_ql/definition_helpers/forwardable.rb

@@ -0,0 +1,10 @@
+# Get `delegate` like Rails has
+module GraphQL::Forwardable
+  def delegate(*methods, to:)
+    methods.each do |method_name|
+      define_method(method_name) do |*args|
+        self.public_send(to).public_send(method_name, *args)
+      end
+    end
+  end
+end

data/lib/graph_ql/definition_helpers/non_null_with_bang.rb

@@ -0,0 +1,9 @@
+# Wrap the object in NonNullType in response to `!`
+# @example required Int type
+#   !GraphQL::INT_TYPE
+#
+module GraphQL::NonNullWithBang
+  def !
+    GraphQL::NonNullType.new(of_type: self)
+  end
+end

data/lib/graph_ql/definition_helpers/string_named_hash.rb

@@ -0,0 +1,12 @@
+# Accepts a hash with symbol keys.
+# - convert keys to strings
+# - if the value responds to `name=`, then assign the hash key as `name`
+class GraphQL::StringNamedHash
+  attr_reader :to_h
+  def initialize(input_hash)
+    @to_h = input_hash
+      .reduce({}) { |memo, (key, value)| memo[key.to_s] = value; memo }
+    # Set the name of the value based on its key
+    @to_h.each {|k, v| v.respond_to?("name=") && v.name = k }
+  end
+end

data/lib/graph_ql/{types → definition_helpers}/type_definer.rb

@@ -5,6 +5,7 @@ class GraphQL::TypeDefiner
   def String;   GraphQL::STRING_TYPE;   end
   def Float;    GraphQL::FLOAT_TYPE;    end
   def Boolean;  GraphQL::BOOLEAN_TYPE;  end
+  def ID;       GraphQL::ID_TYPE;       end
 
   def [](type)
     GraphQL::ListType.new(of_type: type)

data/lib/graph_ql/directive.rb

@@ -1,4 +1,7 @@
-class GraphQL::Directive < GraphQL::ObjectType
+class GraphQL::Directive
+  extend GraphQL::Definable
+  attr_definable :on, :arguments, :name, :description
+
   LOCATIONS = [
     ON_OPERATION =  :on_operation?,
     ON_FRAGMENT =   :on_fragment?,
@@ -8,7 +11,6 @@ class GraphQL::Directive < GraphQL::ObjectType
     define_method(location) { self.on.include?(location) }
   end
 
-  attr_definable :on, :arguments
 
   def initialize
     @arguments = {}
@@ -27,12 +29,14 @@ class GraphQL::Directive < GraphQL::ObjectType
 
   def arguments(new_arguments=nil)
     if !new_arguments.nil?
-      @arguments = new_arguments
-        .reduce({}) {|memo, (k, v)| memo[k.to_s] = v; memo}
-        .each { |k, v| v.respond_to?("name=") && v.name = k}
+      @arguments = GraphQL::StringNamedHash.new(new_arguments).to_h
     end
     @arguments
   end
+
+  def to_s
+    "<GraphQL::Directive #{name}>"
+  end
 end
 
 require 'graph_ql/directives/directive_chain'

data/lib/graph_ql/directives/directive_chain.rb

@@ -24,7 +24,7 @@ class GraphQL::DirectiveChain
       @result = block.call
     else
       applicable_directives.map do |(ast_directive, directive)|
-        args = GraphQL::Query::Arguments.new(ast_directive.arguments, operation_resolver.variables).to_h
+        args = GraphQL::Query::Arguments.new(ast_directive.arguments, directive.arguments, operation_resolver.variables).to_h
         @result = directive.resolve(args, block)
       end
       @result ||= {}

data/lib/graph_ql/field.rb

@@ -16,11 +16,7 @@ class GraphQL::Field
   end
 
   def arguments=(new_arguments)
-    stringified_arguments = new_arguments
-      .reduce({}) { |memo, (key, value)| memo[key.to_s] = value; memo }
-    # Set the name from its context on this type:
-    stringified_arguments.each {|k, v| v.respond_to?("name=") && v.name = k }
-    @arguments = stringified_arguments
+    @arguments = GraphQL::StringNamedHash.new(new_arguments).to_h
   end
 
 

data/lib/graph_ql/parser/transform.rb

@@ -1,9 +1,7 @@
 # {Transform} is a [parslet](http://kschiess.github.io/parslet/) transform for for turning the AST into objects in {GraphQL::Nodes} objects.
 class GraphQL::Transform < Parslet::Transform
   # Get syntax classes by shallow name:
-  def self.const_missing(constant_name)
-    GraphQL::Nodes.const_get(constant_name)
-  end
+  include GraphQL::Nodes
 
   def self.optional_sequence(name)
     rule(name => simple(:val)) { [] }

data/lib/graph_ql/query.rb

@@ -9,7 +9,7 @@ class GraphQL::Query
     @schema = schema
     @debug = debug
     @query_string = query_string
-    @context = context
+    @context = Context.new(context)
     @params = params
     @validate = validate
     @fragments = {}
@@ -48,8 +48,7 @@ class GraphQL::Query
   def execute
     @operations.reduce({}) do |memo, (name, operation)|
       resolver = OperationResolver.new(operation, self)
-      memo[name] = resolver.result
-      memo
+      memo.merge(resolver.result)
     end
   end
 
@@ -62,6 +61,18 @@ class GraphQL::Query
       end
     end
   end
+
+  # Expose some query-specific info to field resolve functions.
+  # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
+  class Context
+    def initialize(arbitrary_hash)
+      @arbitrary_hash = arbitrary_hash
+    end
+
+    def [](key)
+      @arbitrary_hash[key]
+    end
+  end
 end
 
 require 'graph_ql/query/arguments'

data/lib/graph_ql/query/arguments.rb

@@ -1,9 +1,10 @@
 # Creates a plain hash out of arguments, looking up variables if necessary
 class GraphQL::Query::Arguments
   attr_reader :to_h
-  def initialize(ast_arguments, variables)
+  def initialize(ast_arguments, argument_hash, variables)
     @to_h = ast_arguments.reduce({}) do |memo, arg|
-      value = reduce_value(arg.value, variables)
+      arg_defn = argument_hash[arg.name]
+      value = reduce_value(arg.value, arg_defn, variables)
       memo[arg.name] = value
       memo
     end
@@ -11,13 +12,13 @@ class GraphQL::Query::Arguments
 
   private
 
-  def reduce_value(value, variables)
+  def reduce_value(value, arg_defn, variables)
     if value.is_a?(GraphQL::Nodes::VariableIdentifier)
       value = variables[value.name]
     elsif value.is_a?(GraphQL::Nodes::Enum)
-      value = value.name
+      value = arg_defn.type.coerce(value.name)
     elsif value.is_a?(GraphQL::Nodes::InputObject)
-      value = self.class.new(value.pairs, variables).to_h
+      value = self.class.new(value.pairs, arg_defn.type.input_fields, variables).to_h
     else
       value
     end

data/lib/graph_ql/query/field_resolution_strategy.rb

@@ -2,9 +2,9 @@ class GraphQL::Query::FieldResolutionStrategy
   attr_reader :result, :result_value
 
   def initialize(ast_field, parent_type, target, operation_resolver)
-    arguments = GraphQL::Query::Arguments.new(ast_field.arguments, operation_resolver.variables).to_h
     field_name = ast_field.name
     field = parent_type.fields[field_name] || raise("No field found on #{parent_type.name} '#{parent_type}' for '#{field_name}'")
+    arguments = GraphQL::Query::Arguments.new(ast_field.arguments, field.arguments, operation_resolver.variables).to_h
     value = field.resolve(target, arguments, operation_resolver.context)
     if value.nil?
       @result_value = value
@@ -40,9 +40,9 @@ class GraphQL::Query::FieldResolutionStrategy
     attr_reader :result
     def initialize(value, field_type, target, parent_type, ast_field, operation_resolver)
       wrapped_type = field_type.of_type
-      resolved_type = wrapped_type.kind.resolve(wrapped_type, value)
-      strategy_class = GraphQL::Query::FieldResolutionStrategy.get_strategy_for_kind(resolved_type.kind)
       @result = value.map do |item|
+        resolved_type = wrapped_type.kind.resolve(wrapped_type, item)
+        strategy_class = GraphQL::Query::FieldResolutionStrategy.get_strategy_for_kind(resolved_type.kind)
         inner_strategy = strategy_class.new(item, resolved_type, target, parent_type, ast_field, operation_resolver)
         inner_strategy.result
       end

data/lib/graph_ql/{types → scalars}/float_type.rb

@@ -1,6 +1,6 @@
 GraphQL::FLOAT_TYPE = GraphQL::ScalarType.new do |t|
   t.name "Float"
   def t.coerce(value)
-    value.to_f
+    value.respond_to?(:to_f) ? value.to_f : nil
   end
 end

data/lib/graph_ql/scalars/id_type.rb

@@ -0,0 +1,6 @@
+GraphQL::ID_TYPE = GraphQL::ScalarType.new do |t|
+  t.name "ID"
+  def t.coerce(value)
+    value.to_s
+  end
+end

data/lib/graph_ql/{types → scalars}/scalar_type.rb

@@ -2,8 +2,4 @@ class GraphQL::ScalarType < GraphQL::ObjectType
   def kind
     GraphQL::TypeKinds::SCALAR
   end
-
-  def to_s
-    "<GraphQL::ScalarType #{name} >"
-  end
 end

data/lib/graph_ql/static_validation.rb

@@ -3,16 +3,13 @@ end
 
 require 'graph_ql/static_validation/message'
 require 'graph_ql/static_validation/arguments_validator'
-
-require 'graph_ql/static_validation/argument_literals_are_compatible'
-require 'graph_ql/static_validation/arguments_are_defined'
-require 'graph_ql/static_validation/required_arguments_are_present'
-require 'graph_ql/static_validation/fragment_types_exist'
-require 'graph_ql/static_validation/directives_are_defined'
-require 'graph_ql/static_validation/fields_are_defined_on_type'
-require 'graph_ql/static_validation/fields_have_appropriate_selections'
-require 'graph_ql/static_validation/fields_will_merge'
-require 'graph_ql/static_validation/fragments_are_used'
 require 'graph_ql/static_validation/type_stack'
 require 'graph_ql/static_validation/validator'
 require 'graph_ql/static_validation/literal_validator'
+
+rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
+Dir.glob(rules_glob).each do |file|
+  require(file)
+end
+
+require 'graph_ql/static_validation/all_rules'

data/lib/graph_ql/static_validation/all_rules.rb

@@ -0,0 +1,23 @@
+# Default rules for {GraphQL::StaticValidation::Validator}
+#
+# Order is important here. Some validators return {GraphQL::Visitor::SKIP}
+# which stops the visit on that node. That way it doesn't try to find fields on types that
+# don't exist, etc.
+GraphQL::StaticValidation::ALL_RULES = [
+  GraphQL::StaticValidation::DirectivesAreDefined,
+  GraphQL::StaticValidation::FragmentsAreFinite,
+  GraphQL::StaticValidation::FragmentTypesExist,
+  GraphQL::StaticValidation::FragmentsAreOnCompositeTypes,
+  GraphQL::StaticValidation::FragmentSpreadsArePossible,
+  GraphQL::StaticValidation::FragmentsAreUsed,
+  GraphQL::StaticValidation::FieldsAreDefinedOnType,
+  GraphQL::StaticValidation::FieldsWillMerge,
+  GraphQL::StaticValidation::FieldsHaveAppropriateSelections,
+  GraphQL::StaticValidation::ArgumentsAreDefined,
+  GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
+  GraphQL::StaticValidation::RequiredArgumentsArePresent,
+  GraphQL::StaticValidation::VariablesAreInputTypes,
+  GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped,
+  GraphQL::StaticValidation::VariablesAreUsedAndDefined,
+  GraphQL::StaticValidation::VariableUsagesAreAllowed,
+]

data/lib/graph_ql/static_validation/literal_validator.rb

@@ -1,8 +1,5 @@
 # Test whether `ast_value` is a valid input for `type`
 class GraphQL::StaticValidation::LiteralValidator
-  include GraphQL::StaticValidation::Message::MessageHelper
-
-  attr_reader :errors
   def validate(ast_value, type)
     if type.kind.non_null?
       (!ast_value.nil?) && validate(ast_value, type.of_type)

data/lib/graph_ql/static_validation/{arguments_are_defined.rb → rules/arguments_are_defined.rb}

@@ -1,10 +1,15 @@
 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::Visitor::SKIP
       end
     end
+
+    skip
   end
 end

data/lib/graph_ql/static_validation/{fields_will_merge.rb → rules/fields_will_merge.rb}

@@ -10,7 +10,7 @@ class GraphQL::StaticValidation::FieldsWillMerge
     }
     visitor[GraphQL::Nodes::Document].leave << -> (node, parent) {
       has_selections.each { |node|
-        field_map = gather_fields_by_name(node.selections, {}, context)
+        field_map = gather_fields_by_name(node.selections, {}, [], context)
         find_conflicts(field_map, context)
       }
     }
@@ -23,18 +23,26 @@ class GraphQL::StaticValidation::FieldsWillMerge
       comparison = FieldDefinitionComparison.new(name, ast_fields)
       context.errors.push(*comparison.errors)
 
-      subfield_map = ast_fields.reduce({}) do |memo, defn|
-        gather_fields_by_name(defn.selections, memo, context)
+
+      subfield_map = {}
+      visited_fragments = []
+      ast_fields.each do |defn|
+        gather_fields_by_name(defn.selections, subfield_map, visited_fragments, context)
       end
       find_conflicts(subfield_map, context)
     end
   end
 
-  def gather_fields_by_name(fields, field_map, context)
+  def gather_fields_by_name(fields, field_map, visited_fragments, context)
     fields.each do |field|
       if field.is_a?(GraphQL::Nodes::InlineFragment)
         next_fields = field.selections
       elsif field.is_a?(GraphQL::Nodes::FragmentSpread)
+        if visited_fragments.include?(field.name)
+          next
+        else
+          visited_fragments << field.name
+        end
         fragment = context.fragments[field.name]
         next_fields = fragment.selections
       else
@@ -43,7 +51,7 @@ class GraphQL::StaticValidation::FieldsWillMerge
         field_map[name_in_selection].push(field)
         next_fields = []
       end
-      gather_fields_by_name(next_fields, field_map, context)
+      gather_fields_by_name(next_fields, field_map, visited_fragments, context)
     end
     field_map
   end

data/lib/graph_ql/static_validation/rules/fragment_spreads_are_possible.rb

@@ -0,0 +1,50 @@
+class GraphQL::StaticValidation::FragmentSpreadsArePossible
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+
+    context.visitor[GraphQL::Nodes::InlineFragment] << -> (node, parent) {
+      fragment_parent = context.object_types[-2]
+      fragment_child = context.object_types.last
+      validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
+    }
+
+    spreads_to_validate = []
+
+    context.visitor[GraphQL::Nodes::FragmentSpread] << -> (node, parent) {
+      fragment_parent = context.object_types.last
+      spreads_to_validate << [node, fragment_parent]
+    }
+
+    context.visitor[GraphQL::Nodes::Document].leave << -> (node, parent) {
+      spreads_to_validate.each do |spread_values|
+        node, fragment_parent = spread_values
+        fragment_child_name = context.fragments[node.name].type
+        fragment_child = context.schema.types[fragment_child_name]
+        validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
+      end
+    }
+  end
+
+  private
+
+  def validate_fragment_in_scope(parent_type, child_type, node, context)
+    intersecting_types = get_possible_types(parent_type) & get_possible_types(child_type)
+    if intersecting_types.none?
+      name = node.respond_to?(:name) ? " #{node.name}" : ""
+      context.errors << message("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node)
+    end
+  end
+
+  def get_possible_types(type)
+    if type.kind.wraps?
+      get_possible_types(type.of_type)
+    elsif type.kind.object?
+      [type]
+    elsif type.kind.resolves?
+      type.possible_types
+    else
+      []
+    end
+  end
+end