graphql 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 361de5aace2ae0ad425b1c59da22dbc53128020e
-  data.tar.gz: d2927200177cdc6c5d26f82feb195180d9e631da
+  metadata.gz: 9893aa36baed8d8eef998b94e2a7e1e160f6bc30
+  data.tar.gz: 838caa42e67801cf03761deae983200af1eccb71
 SHA512:
-  metadata.gz: a9b4d287ff8fe030fdb5b7693b1e418cbdbd8f4c2f50c99f6e2daef14501a39b60afbdaba2ec1a6958cf4f7ef6cf9cd13028779565f34cc81ffc08df01ceffd8
-  data.tar.gz: d775e65e4736ab0ed9fb9502c4f42d0a59ea5703efc3c9174e68a9f25300377b3c6236e7f818967e6a6cccd83ad5316c1b9259c70313972a313bc93aed2c90f8
+  metadata.gz: b54e1f57376d148e3c8f6df3043bb4cde33f27374b02c3022ce96ebd39d5fc3bda70e60737501c29963ec320e510c1c2f593b904f651dfcd1603e24c074aa3a6
+  data.tar.gz: f3086c08018736a123143ae7221fc4b7ea7df30430eabd43d154bace39364235ad1383ca55022389ec8b115fe6944e6d416340e9dfb88c2e25bf13d5a1b06850

data/lib/graphql.rb

@@ -1,3 +1,4 @@
+require "celluloid/current"
 require "json"
 require "parslet"
 require "singleton"
@@ -20,6 +21,7 @@ end
 # Order matters for these:
 
 require 'graphql/definition_helpers'
+require 'graphql/base_type'
 require 'graphql/object_type'
 
 require 'graphql/enum_type'

data/lib/graphql/base_type.rb

@@ -0,0 +1,79 @@
+module GraphQL
+  # The parent for all type classes.
+  class BaseType
+    include GraphQL::DefinitionHelpers::NonNullWithBang
+    include GraphQL::DefinitionHelpers::DefinedByConfig
+
+    # @param other [GraphQL::BaseType] compare to this object
+    # @return [Boolean] are these types equivalent? (incl. non-null, list)
+    def ==(other)
+      if other.is_a?(GraphQL::BaseType)
+        self.to_s == other.to_s
+      else
+        super
+      end
+    end
+
+    # If this type is modifying an underlying type,
+    # return the underlying type. (Otherwise, return `self`.)
+    def unwrap
+      self
+    end
+
+    module ModifiesAnotherType
+      def unwrap
+        self.of_type.unwrap
+      end
+    end
+
+    # Find out which possible type to use for `value`.
+    # Returns self if there are no possible types (ie, not Union or Interface)
+    def resolve_type(value)
+      self
+    end
+
+    module HasPossibleTypes
+      # Return the implementing type for `object`.
+      # The default implementation assumes that there's a type with the same name as `object.class.name`.
+      # Maybe you'll need to override this in your own interfaces!
+      #
+      # @param object [Object] the object which needs a type to expose it
+      # @return [GraphQL::ObjectType] the type which should expose `object`
+      def resolve_type(object)
+        instance_exec(object, &@resolve_type_proc)
+      end
+
+      # The default implementation of {#resolve_type} gets `object.class.name`
+      # and finds a type with the same name
+      DEFAULT_RESOLVE_TYPE = -> (object) {
+        type_name = object.class.name
+        possible_types.find {|t| t.name == type_name}
+      }
+
+      def resolve_type=(new_proc)
+        @resolve_type_proc = new_proc || DEFAULT_RESOLVE_TYPE
+      end
+    end
+
+    # Print the human-readable name of this type
+    def to_s
+      Printer.instance.print(self)
+    end
+
+    alias :inspect :to_s
+
+    # Print a type, using the query-style naming pattern
+    class Printer
+      include Singleton
+      def print(type)
+        if type.kind.non_null?
+          "#{print(type.of_type)}!"
+        elsif type.kind.list?
+          "[#{print(type.of_type)}]"
+        else
+          type.name
+        end
+      end
+    end
+  end
+end

data/lib/graphql/enum_type.rb

@@ -10,9 +10,7 @@
 #     value("RUBY", "A very dynamic language aimed at programmer happiness")
 #     value("JAVASCRIPT", "Accidental lingua franca of the web")
 #   end
-class GraphQL::EnumType
-  include GraphQL::DefinitionHelpers::NonNullWithBang
-  include GraphQL::DefinitionHelpers::DefinedByConfig
+class GraphQL::EnumType < GraphQL::BaseType
   attr_accessor :name, :description, :values
   defined_by_config :name, :description, :values
 

data/lib/graphql/input_object_type.rb

@@ -7,8 +7,8 @@
 #     input_field :number, !types.Int
 #   end
 #
-class GraphQL::InputObjectType < GraphQL::ObjectType
-  attr_accessor :input_fields
+class GraphQL::InputObjectType < GraphQL::BaseType
+  attr_accessor :name, :description, :input_fields
   defined_by_config :name, :description, :input_fields
 
   def input_fields=(new_fields)

data/lib/graphql/interface_type.rb

@@ -10,15 +10,10 @@
 #     field :release_year, types.Int
 #   end
 #
-class GraphQL::InterfaceType < GraphQL::ObjectType
+class GraphQL::InterfaceType < GraphQL::BaseType
+  include GraphQL::BaseType::HasPossibleTypes
   defined_by_config :name, :description, :fields, :resolve_type
-
-  # The default implementation of {#resolve_type} gets `object.class.name`
-  # and finds a type with the same name
-  DEFAULT_RESOLVE_TYPE = -> (object) {
-    type_name = object.class.name
-    possible_types.find {|t| t.name == type_name}
-  }
+  attr_accessor :name, :description, :fields
 
   def kind
     GraphQL::TypeKinds::INTERFACE
@@ -28,18 +23,4 @@ class GraphQL::InterfaceType < GraphQL::ObjectType
   def possible_types
     @possible_types ||= []
   end
-
-  # Return the implementing type for `object`.
-  # The default implementation assumes that there's a type with the same name as `object.class.name`.
-  # Maybe you'll need to override this in your own interfaces!
-  #
-  # @param object [Object] the object which needs a type to expose it
-  # @return [GraphQL::ObjectType] the type which should expose `object`
-  def resolve_type(object)
-    instance_exec(object, &@resolve_type_proc)
-  end
-
-  def resolve_type=(new_proc)
-    @resolve_type_proc = new_proc || DEFAULT_RESOLVE_TYPE
-  end
 end

data/lib/graphql/list_type.rb

@@ -1,12 +1,14 @@
 # A list type wraps another type.
 #
-# See {TypeKind#unwrap} for accessing the modified type
-class GraphQL::ListType < GraphQL::ObjectType
-  attr_reader :of_type
+# Get the underlying type with {#unwrap}
+class GraphQL::ListType < GraphQL::BaseType
+  include GraphQL::BaseType::ModifiesAnotherType
+  attr_reader :of_type, :name
   def initialize(of_type:)
     @name = "List"
     @of_type = of_type
   end
+
   def kind
     GraphQL::TypeKinds::LIST
   end

data/lib/graphql/non_null_type.rb

@@ -1,7 +1,9 @@
 # A non-null type wraps another type.
 #
-# See {TypeKind#unwrap} for accessing the modified type
-class GraphQL::NonNullType < GraphQL::ObjectType
+# Get the underlying type with {#unwrap}
+class GraphQL::NonNullType < GraphQL::BaseType
+  include GraphQL::BaseType::ModifiesAnotherType
+
   attr_reader :of_type
   def initialize(of_type:)
     @of_type = of_type

data/lib/graphql/object_type.rb

@@ -19,9 +19,7 @@
 #       end
 #    end
 #
-class GraphQL::ObjectType
-  include GraphQL::DefinitionHelpers::NonNullWithBang
-  include GraphQL::DefinitionHelpers::DefinedByConfig
+class GraphQL::ObjectType < GraphQL::BaseType
   defined_by_config :name, :description, :interfaces, :fields
   attr_accessor :name, :description, :interfaces, :fields
 
@@ -43,35 +41,4 @@ class GraphQL::ObjectType
   def kind
     GraphQL::TypeKinds::OBJECT
   end
-
-  # Print the human-readable name of this type
-  def to_s
-    Printer.instance.print(self)
-  end
-
-  alias :inspect :to_s
-
-  # @param other [GraphQL::ObjectType] compare to this object
-  # @return [Boolean] are these types equivalent? (incl. non-null, list)
-  def ==(other)
-    if other.is_a?(GraphQL::ObjectType)
-      self.to_s == other.to_s
-    else
-      super
-    end
-  end
-
-  # Print a type, using the query-style naming pattern
-  class Printer
-    include Singleton
-    def print(type)
-      if type.kind.non_null?
-        "#{print(type.of_type)}!"
-      elsif type.kind.list?
-        "[#{print(type.of_type)}]"
-      else
-        type.name
-      end
-    end
-  end
 end

data/lib/graphql/query.rb

@@ -16,7 +16,7 @@ class GraphQL::Query
   def initialize(schema, query_string, context: nil, variables: {}, debug: true, validate: true, operation_name: nil)
     @schema = schema
     @debug = debug
-    @context = Context.new(context)
+    @context = Context.new(values: context)
 
     @variables = variables
     @validate = validate
@@ -52,12 +52,17 @@ class GraphQL::Query
   # 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
+    attr_accessor :execution_strategy, :ast_node
+    def initialize(values:)
+      @values = values
     end
 
     def [](key)
-      @arbitrary_hash[key]
+      @values[key]
+    end
+
+    def async(&block)
+      execution_strategy.async(block)
     end
   end
 end
@@ -65,7 +70,7 @@ end
 require 'graphql/query/arguments'
 require 'graphql/query/base_execution'
 require 'graphql/query/serial_execution'
-require 'graphql/query/value_resolution'
+require 'graphql/query/parallel_execution'
 require 'graphql/query/type_resolver'
 require 'graphql/query/directive_chain'
 require 'graphql/query/executor'

data/lib/graphql/query/arguments.rb

@@ -27,7 +27,7 @@ class GraphQL::Query::Arguments
     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.kind.unwrap(arg_defn.type)
+      wrapped_type = arg_defn.type.unwrap
       value = self.class.new(value.pairs, wrapped_type.input_fields, variables)
     else
       value

data/lib/graphql/query/base_execution.rb

@@ -1,6 +1,21 @@
+require 'graphql/query/base_execution/selected_object_resolution'
+require 'graphql/query/base_execution/value_resolution'
+
 module GraphQL
   class Query
     class BaseExecution
+      # This is the only required method for an Execution strategy.
+      # You could create a custom execution strategy and configure your schema to
+      # use that custom strategy instead.
+      #
+      # @param ast_operation [GraphQL::Language::Nodes::OperationDefinition] The operation definition to run
+      # @param root_type [GraphQL::ObjectType] either the query type or the mutation type
+      # @param query_obj [GraphQL::Query] the query object for this execution
+      # @return [Hash] a spec-compliant GraphQL result, as a hash
+      def execute(ast_operation, root_type, query_obj)
+        resolver = operation_resolution.new(ast_operation, root_type, query_obj, self)
+        resolver.result
+      end
 
       def field_resolution
         get_class :FieldResolution
@@ -22,6 +37,12 @@ module GraphQL
         get_class :SelectionResolution
       end
 
+      # ParallelExecution overrides this to provide
+      # real async behavior
+      def async(&block)
+        block.call
+      end
+
       private
 
       def get_class(class_name)
@@ -30,5 +51,3 @@ module GraphQL
     end
   end
 end
-
-require 'graphql/query/base_execution/selected_object_resolution'

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

@@ -0,0 +1,82 @@
+module GraphQL
+  class Query
+    class BaseExecution
+      module ValueResolution
+        def self.get_strategy_for_kind(kind)
+          TYPE_KIND_STRATEGIES[kind] || raise("No value resolution strategy for #{kind}!")
+        end
+
+        class BaseResolution
+          attr_reader :value, :field_type, :target, :parent_type,
+            :ast_field, :query, :execution_strategy
+          def initialize(value, field_type, target, parent_type, ast_field, query, execution_strategy)
+            @value = value
+            @field_type = field_type
+            @target = target
+            @parent_type = parent_type
+            @ast_field = ast_field
+            @query = query
+            @execution_strategy = execution_strategy
+          end
+
+          def result
+            raise NotImplementedError, "Should return a value based on initialization params"
+          end
+
+          def get_strategy_for_kind(*args)
+            GraphQL::Query::BaseExecution::ValueResolution.get_strategy_for_kind(*args)
+          end
+        end
+
+        class ScalarResolution < BaseResolution
+          def result
+            field_type.coerce(value)
+          end
+        end
+
+        class ListResolution < BaseResolution
+          def result
+            wrapped_type = field_type.of_type
+            value.map do |item|
+              resolved_type = wrapped_type.resolve_type(item)
+              strategy_class = get_strategy_for_kind(resolved_type.kind)
+              inner_strategy = strategy_class.new(item, resolved_type, target, parent_type, ast_field, query, execution_strategy)
+              inner_strategy.result
+            end
+          end
+        end
+
+        class ObjectResolution < BaseResolution
+          def result
+            resolver = execution_strategy.selection_resolution.new(value, field_type, ast_field.selections, query, execution_strategy)
+            resolver.result
+          end
+        end
+
+        class EnumResolution < BaseResolution
+          def result
+             value.to_s
+          end
+        end
+
+        class NonNullResolution < BaseResolution
+          def result
+            wrapped_type = field_type.of_type
+            resolved_type = wrapped_type.resolve_type(value)
+            strategy_class = get_strategy_for_kind(resolved_type.kind)
+            inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, query, execution_strategy)
+            inner_strategy.result
+          end
+        end
+
+        TYPE_KIND_STRATEGIES = {
+          GraphQL::TypeKinds::SCALAR =>     ScalarResolution,
+          GraphQL::TypeKinds::LIST =>       ListResolution,
+          GraphQL::TypeKinds::OBJECT =>     ObjectResolution,
+          GraphQL::TypeKinds::ENUM =>       EnumResolution,
+          GraphQL::TypeKinds::NON_NULL =>   NonNullResolution,
+        }
+      end
+    end
+  end
+end

data/lib/graphql/query/executor.rb

@@ -30,13 +30,15 @@ module GraphQL
         return {} if query.operations.none?
         operation = find_operation(operation_name, query.operations)
         if operation.operation_type == "query"
-          root = query.schema.query
+          root_type = query.schema.query
+          execution_strategy_class = query.schema.query_execution_strategy || GraphQL::Query::ParallelExecution
         elsif operation.operation_type == "mutation"
-          root = query.schema.mutation
+          root_type = query.schema.mutation
+          execution_strategy_class =  query.schema.mutation_execution_strategy || GraphQL::Query::SerialExecution
         end
-        execution_strategy = GraphQL::Query::SerialExecution.new
-        resolver = execution_strategy.operation_resolution.new(operation, root, query, execution_strategy)
-        resolver.result
+        execution_strategy = execution_strategy_class.new
+        query.context.execution_strategy = execution_strategy
+        result = execution_strategy.execute(operation, root_type, query)
       end
 
       def find_operation(operation_name, operations)

data/lib/graphql/query/parallel_execution.rb

@@ -0,0 +1,101 @@
+module GraphQL
+  class Query
+    # Utilize Celluloid::Future to run field resolution in parallel.
+    class ParallelExecution < GraphQL::Query::BaseExecution
+      def initialize
+        # Why isn't `require "celluloid/current"` enough here?
+        Celluloid.boot unless Celluloid.running?
+        @has_futures = false
+      end
+
+      def pool
+        @pool ||= ExecutionPool.run!
+        @pool[:execution_worker_pool]
+      end
+
+      def async(block)
+        @has_futures ||= true
+        pool.future.resolve(block)
+      end
+
+      def has_futures?
+        @has_futures
+      end
+
+      class OperationResolution < GraphQL::Query::SerialExecution::OperationResolution
+        def result
+          result_futures = super
+          if execution_strategy.has_futures?
+            finished_result = finish_all_futures(result_futures)
+          else
+            # Don't bother re-traversing the result if there are no futures.
+            finished_result = result_futures
+          end
+        ensure
+          execution_strategy.pool.terminate
+          finished_result
+        end
+
+        # Recurse over `result_object`, finding any futures and
+        # getting their finished values.
+        def finish_all_futures(result_object)
+          if result_object.is_a?(FutureFieldResolution)
+            resolved_value = finish_all_futures(result_object.result)
+          elsif result_object.is_a?(Hash)
+            result_object.each do |key, value|
+              result_object[key] = finish_all_futures(value)
+            end
+            resolved_value = result_object
+          elsif result_object.is_a?(Array)
+            resolved_value = result_object.map { |v| finish_all_futures(v) }
+          else
+            resolved_value = result_object
+          end
+        end
+      end
+
+      class SelectionResolution < GraphQL::Query::SerialExecution::SelectionResolution
+      end
+
+      class FieldResolution < GraphQL::Query::SerialExecution::FieldResolution
+        def get_finished_value(raw_value)
+          if raw_value.is_a?(Celluloid::Future)
+            GraphQL::Query::ParallelExecution::FutureFieldResolution.new(field_resolution: self, future: raw_value)
+          else
+            super
+          end
+        end
+      end
+
+      class InlineFragmentResolution < GraphQL::Query::SerialExecution::InlineFragmentResolution
+      end
+
+      class FragmentSpreadResolution < GraphQL::Query::SerialExecution::FragmentSpreadResolution
+      end
+
+      class ExecutionWorker
+        include Celluloid
+        def resolve(proc)
+          proc.call
+        end
+      end
+
+      class ExecutionPool < Celluloid::Supervision::Container
+        pool ExecutionWorker, as: :execution_worker_pool
+      end
+
+      class FutureFieldResolution
+        def initialize(field_resolution:, future:)
+          @field_resolution = field_resolution
+          @future = future
+        end
+
+        def result
+          resolved_value = @future.value
+          result_value = @field_resolution.get_finished_value(resolved_value)
+          result_value
+        end
+      end
+    end
+  end
+end