graphql 0.9.5 → 0.10.0

data/lib/graphql/query/arguments.rb

@@ -1,34 +1,37 @@
-# Provide read-only access to arguments by string or symbol names.
-class GraphQL::Query::Arguments
-  extend Forwardable
+module GraphQL
+  class Query
+    # Read-only access to values, normalizing all keys to strings
+    #
+    # {Arguments} recursively wraps the input in {Arguments} instances.
+    class Arguments
+      extend Forwardable
 
-  def initialize(ast_arguments, argument_hash, variables)
-    @hash = ast_arguments.reduce({}) do |memo, arg|
-      arg_defn = argument_hash[arg.name]
-      value = reduce_value(arg.value, arg_defn, variables)
-      memo[arg.name] = value
-      memo
-    end
-  end
+      def initialize(values)
+        @values = values.inject({}) do |memo, (inner_key, inner_value)|
+          memo[inner_key] = wrap_value(inner_value)
+          memo
+        end
+      end
 
-  def_delegators :@hash, :keys, :values, :inspect, :to_h
+      # @param [String, Symbol] name or index of value to access
+      # @return [Object] the argument at that key
+      def [](key)
+        @values[key.to_s]
+      end
 
-  def [](key)
-    @hash[key.to_s]
-  end
+      def_delegators :@values_hash, :keys, :values, :each
 
-  private
+      private
 
-  def reduce_value(value, arg_defn, variables)
-    if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-      value = variables[value.name]
-    elsif value.is_a?(GraphQL::Language::Nodes::Enum)
-      value = arg_defn.type.coerce(value.name)
-    elsif value.is_a?(GraphQL::Language::Nodes::InputObject)
-      wrapped_type = arg_defn.type.unwrap
-      value = self.class.new(value.pairs, wrapped_type.input_fields, variables)
-    else
-      value
+      def wrap_value(value)
+        if value.is_a?(Array)
+          value.map { |item| wrap_value(item) }
+        elsif value.is_a?(Hash)
+          self.class.new(value)
+        else
+          value
+        end
+      end
     end
   end
 end

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

@@ -29,9 +29,9 @@ module GraphQL
         end
 
         class ScalarResolution < BaseResolution
-          # Apply the scalar's defined `coerce` method to the value
+          # Apply the scalar's defined `coerce_result` method to the value
           def result
-            field_type.coerce(value)
+            field_type.coerce_result(value)
           end
         end
 
@@ -60,7 +60,7 @@ module GraphQL
         class EnumResolution < BaseResolution
           # Get the string name for this enum value
           def result
-             value.to_s
+            field_type.coerce_result(value)
           end
         end
 

data/lib/graphql/query/directive_chain.rb

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

data/lib/graphql/query/executor.rb

@@ -1,23 +1,11 @@
 module GraphQL
   class Query
     class Executor
-      class OperationNameMissingError < StandardError
-        def initialize(names)
-          msg = "You must provide an operation name from: #{names.join(", ")}"
-          super(msg)
-        end
-      end
-
       # @return [GraphQL::Query] the query being executed
       attr_reader :query
 
-      # @return [String] the operation to run in {query}
-      attr_reader :operation_name
-
-
-      def initialize(query, operation_name)
+      def initialize(query)
         @query = query
-        @operation_name = operation_name
       end
 
       # Evalute {operation_name} on {query}. Handle errors by putting them in the "errors" key.
@@ -25,19 +13,20 @@ module GraphQL
       # @return [Hash] A GraphQL response, with either a "data" key or an "errors" key
       def result
         execute
-      rescue OperationNameMissingError => err
+      rescue GraphQL::Query::OperationNameMissingError, GraphQL::Query::VariableMissingError => err
         {"errors" => [{"message" => err.message}]}
       rescue StandardError => err
         query.debug && raise(err)
-        message = "Something went wrong during query execution: #{err}" # \n  #{err.backtrace.join("\n  ")}"
+        message = "Something went wrong during query execution: #{err}" #\n#{err.backtrace.join("\n  ")}"
         {"errors" => [{"message" => message}]}
       end
 
       private
 
       def execute
-        return {} if query.operations.none?
-        operation = find_operation(operation_name, query.operations)
+        operation = query.selected_operation
+        return {} if operation.nil?
+
         if operation.operation_type == "query"
           root_type = query.schema.query
           execution_strategy_class = query.schema.query_execution_strategy
@@ -57,16 +46,6 @@ module GraphQL
 
         result
       end
-
-      def find_operation(operation_name, operations)
-        if operations.length == 1
-          operations.values.first
-        elsif !operations.key?(operation_name)
-          raise OperationNameMissingError, operations.keys
-        else
-          operations[operation_name]
-        end
-      end
     end
   end
 end

data/lib/graphql/query/literal_input.rb

@@ -0,0 +1,89 @@
+module GraphQL
+  class Query
+    # Turn query string values into something useful for query execution
+    class LiteralInput
+      attr_reader :variables, :value, :type
+      def initialize(type, incoming_value, variables)
+        @type = type
+        @value = incoming_value
+        @variables = variables
+      end
+
+      def graphql_value
+        if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          variables[value.name] # Already cleaned up with RubyInput
+        elsif type.kind.input_object?
+          input_values = {}
+          inner_type = type.unwrap
+          inner_type.input_fields.each do |arg_name, arg_defn|
+            ast_arg = value.pairs.find { |ast_arg| ast_arg.name == arg_name }
+            raw_value = resolve_argument_value(ast_arg, arg_defn, variables)
+            reduced_value = coerce(arg_defn.type, raw_value, variables)
+            input_values[arg_name] = reduced_value
+          end
+          input_values
+        elsif type.kind.list?
+          inner_type = type.of_type
+          value.map { |item| coerce(inner_type, item, variables) }
+        elsif type.kind.non_null?
+          inner_type = type.of_type
+          coerce(inner_type, value, variables)
+        elsif type.kind.scalar?
+          type.coerce_input!(value)
+        elsif type.kind.enum?
+          value_name = value.name # it's a Nodes::Enum
+          type.coerce_input!(value_name)
+        else
+          raise "Unknown input #{value} of type #{type}"
+        end
+      end
+
+      def self.coerce(type, value, variables)
+        input = self.new(type, value, variables)
+        input.graphql_value
+      end
+
+      def self.from_arguments(ast_arguments, argument_defns, variables)
+        values_hash = {}
+        argument_defns.each do |arg_name, arg_defn|
+          ast_arg = ast_arguments.find { |ast_arg| ast_arg.name == arg_name }
+          arg_value = nil
+          if ast_arg
+            arg_value = coerce(arg_defn.type, ast_arg.value, variables)
+          end
+          if arg_value.nil?
+            arg_value = arg_defn.default_value
+          end
+          values_hash[arg_name] = arg_value
+        end
+        GraphQL::Query::Arguments.new(values_hash)
+      end
+
+      private
+
+      def coerce(*args)
+        self.class.coerce(*args)
+      end
+
+      def resolve_argument_value(*args)
+        self.class.resolve_argument_value(*args)
+      end
+
+      # Prefer values in this order:
+      # - Literal value from the query string
+      # - Variable value from query varibles
+      # - Default value from Argument definition
+      def self.resolve_argument_value(ast_arg, arg_defn, variables)
+        if !ast_arg.nil?
+          raw_value = ast_arg.value
+        end
+
+        if raw_value.nil?
+          raw_value = arg_defn.default_value
+        end
+
+        raw_value
+      end
+    end
+  end
+end

data/lib/graphql/query/ruby_input.rb

@@ -0,0 +1,20 @@
+module GraphQL
+  class Query
+    # Turn Ruby values into something useful for query execution
+    class RubyInput
+      def initialize(type, incoming_value)
+        @type = type
+        @incoming_value = incoming_value
+      end
+
+      def graphql_value
+        @type.coerce_input!(@incoming_value)
+      end
+
+      def self.coerce(type, value)
+        input = self.new(type, value)
+        input.graphql_value
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module GraphQL
           @query = query
           @execution_strategy = execution_strategy
           @field = query.schema.get_field(parent_type, ast_node.name) || raise("No field found on #{parent_type.name} '#{parent_type}' for '#{ast_node.name}'")
-          @arguments = GraphQL::Query::Arguments.new(ast_node.arguments, field.arguments, query.variables)
+          @arguments = GraphQL::Query::LiteralInput.from_arguments(ast_node.arguments, field.arguments, query.variables)
         end
 
         def result

data/lib/graphql/query/variables.rb

@@ -0,0 +1,39 @@
+module GraphQL
+  class Query
+    # Read-only access to query variables, applying default values if needed.
+    class Variables
+      def initialize(schema, ast_variables, provided_variables)
+        @schema = schema
+        @provided_variables = provided_variables
+        @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
+          variable_name = ast_variable.name
+          memo[variable_name] = get_graphql_value(ast_variable)
+        end
+      end
+
+      def [](key)
+        @storage.fetch(key)
+      end
+
+      private
+
+      # Find the right value for this variable:
+      # - First, use the value provided at runtime
+      # - Then, fall back to the default value from the query string
+      # If it's still nil, raise an error if it's required.
+      def get_graphql_value(ast_variable)
+        variable_type = @schema.type_from_ast(ast_variable.type)
+        variable_name = ast_variable.name
+        default_value = ast_variable.default_value
+        provided_value = @provided_variables[variable_name]
+        if !provided_value.nil?
+          graphql_value = GraphQL::Query::RubyInput.coerce(variable_type, provided_value)
+        elsif !default_value.nil?
+          graphql_value = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
+        elsif variable_type.kind.non_null?
+          raise GraphQL::Query::VariableMissingError.new(variable_name, variable_type)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/scalar_type.rb

@@ -1,16 +1,38 @@
 module GraphQL
   # The parent type for scalars, eg {GraphQL::STRING_TYPE}, {GraphQL::INT_TYPE}
   #
+  # @example defining a type for Time
+  #   TimeType = GraphQL::ObjectType.define do
+  #     name "Time"
+  #     description "Time since epoch in seconds"
+  #
+  #     coerce_input ->(value) { Time.at(Float(value)) }
+  #     coerce_result ->(value) { value.to_f }
+  #   end
+  #
   class ScalarType < GraphQL::BaseType
-    defined_by_config :name, :coerce, :description
+    defined_by_config :name, :coerce, :coerce_input, :coerce_result, :description
     attr_accessor :name, :description
 
-    def coerce(value)
-      @coerce_proc.call(value)
+    def coerce=(proc)
+      self.coerce_input = proc
+      self.coerce_result = proc
     end
 
-    def coerce=(proc)
-      @coerce_proc = proc
+    def coerce_input(value)
+      @coerce_input_proc.call(value)
+    end
+
+    def coerce_input=(proc)
+      @coerce_input_proc = proc unless proc.nil?
+    end
+
+    def coerce_result(value)
+      @coerce_result_proc.call(value)
+    end
+
+    def coerce_result=(proc)
+      @coerce_result_proc = proc unless proc.nil?
     end
 
     def kind

data/lib/graphql/schema.rb

@@ -58,6 +58,10 @@ class GraphQL::Schema
     end
   end
 
+  def type_from_ast(ast_node)
+    GraphQL::Schema::TypeExpression.new(self, ast_node).type
+  end
+
   class InvalidTypeError < StandardError
     def initialize(type, errors)
       super("Type #{type.respond_to?(:name) ? type.name :  "Unnamed type" } is invalid: #{errors.join(", ")}")
@@ -70,6 +74,7 @@ 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'

data/lib/graphql/schema/type_expression.rb

@@ -0,0 +1,28 @@
+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)
+          type_name = ast_node.name
+          schema.types[type_name]
+        elsif ast_node.is_a?(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)
+          ast_inner_type = ast_node.of_type
+          build_type(schema, ast_inner_type).to_list_type
+        end
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/literal_validator.rb

@@ -7,9 +7,9 @@ class GraphQL::StaticValidation::LiteralValidator
       item_type = type.of_type
       ast_value.all? { |val| validate(val, item_type) }
     elsif type.kind.scalar?
-      !type.coerce(ast_value).nil?
+      !type.coerce_input(ast_value).nil?
     elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-      !type.coerce(ast_value.name).nil?
+      !type.coerce_input(ast_value.name).nil?
     elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
       fields = type.input_fields
       ast_value.pairs.all? do |value|
@@ -17,6 +17,9 @@ class GraphQL::StaticValidation::LiteralValidator
         present_if_required = field_type.kind.non_null? ? !value.nil? : true
         present_if_required && validate(value.value, field_type)
       end
+    elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+      # Todo: somehow pass in the document's variable definitions and validate this
+      true
     else
       false
     end

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

@@ -1,8 +1,6 @@
 class GraphQL::StaticValidation::FieldsAreDefinedOnType
   include GraphQL::StaticValidation::Message::MessageHelper
 
-  IS_FIELD = Proc.new {|f| f.is_a?(GraphQL::Language::Nodes::Field) }
-
   def validate(context)
     visitor = context.visitor
     visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {