graphql 0.16.0 → 2.0.15

data/lib/graphql/execution/interpreter.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+require "fiber"
+require "graphql/execution/interpreter/argument_value"
+require "graphql/execution/interpreter/arguments"
+require "graphql/execution/interpreter/arguments_cache"
+require "graphql/execution/interpreter/execution_errors"
+require "graphql/execution/interpreter/runtime"
+require "graphql/execution/interpreter/resolve"
+require "graphql/execution/interpreter/handles_raw_value"
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class << self
+        # Used internally to signal that the query shouldn't be executed
+        # @api private
+        NO_OPERATION = {}.freeze
+
+        # @param schema [GraphQL::Schema]
+        # @param queries [Array<GraphQL::Query, Hash>]
+        # @param context [Hash]
+        # @param max_complexity [Integer, nil]
+        # @return [Array<Hash>] One result per query
+        def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+          queries = query_options.map do |opts|
+            case opts
+            when Hash
+              GraphQL::Query.new(schema, nil, **opts)
+            when GraphQL::Query
+              opts
+            else
+              raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+            end
+          end
+
+          multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
+            schema = multiplex.schema
+            queries = multiplex.queries
+            query_instrumenters = schema.instrumenters[:query]
+            multiplex_instrumenters = schema.instrumenters[:multiplex]
+
+            # First, run multiplex instrumentation, then query instrumentation for each query
+            call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
+              each_query_call_hooks(query_instrumenters, queries) do
+                schema = multiplex.schema
+                multiplex_analyzers = schema.multiplex_analyzers
+                queries = multiplex.queries
+                if multiplex.max_complexity
+                  multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+                end
+
+                schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+                begin
+                  # Since this is basically the batching context,
+                  # share it for a whole multiplex
+                  multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
+                  # Do as much eager evaluation of the query as possible
+                  results = []
+                  queries.each_with_index do |query, idx|
+                    multiplex.dataloader.append_job {
+                      operation = query.selected_operation
+                      result = if operation.nil? || !query.valid? || query.context.errors.any?
+                        NO_OPERATION
+                      else
+                        begin
+                          # Although queries in a multiplex _share_ an Interpreter instance,
+                          # they also have another item of state, which is private to that query
+                          # in particular, assign it here:
+                          runtime = Runtime.new(query: query)
+                          query.context.namespace(:interpreter_runtime)[:runtime] = runtime
+
+                          query.trace("execute_query", {query: query}) do
+                            runtime.run_eager
+                          end
+                        rescue GraphQL::ExecutionError => err
+                          query.context.errors << err
+                          NO_OPERATION
+                        end
+                      end
+                      results[idx] = result
+                    }
+                  end
+
+                  multiplex.dataloader.run
+
+                  # Then, work through lazy results in a breadth-first way
+                  multiplex.dataloader.append_job {
+                    tracer = multiplex
+                    query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
+                    queries = multiplex ? multiplex.queries : [query]
+                    final_values = queries.map do |query|
+                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                      # it might not be present if the query has an error
+                      runtime ? runtime.final_result : nil
+                    end
+                    final_values.compact!
+                    tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
+                      Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
+                    end
+                    queries.each do |query|
+                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                      if runtime
+                        runtime.delete_interpreter_context(:current_path)
+                        runtime.delete_interpreter_context(:current_field)
+                        runtime.delete_interpreter_context(:current_object)
+                        runtime.delete_interpreter_context(:current_arguments)
+                      end
+                    end
+                  }
+                  multiplex.dataloader.run
+
+                  # Then, find all errors and assign the result to the query object
+                  results.each_with_index do |data_result, idx|
+                    query = queries[idx]
+                    # Assign the result so that it can be accessed in instrumentation
+                    query.result_values = if data_result.equal?(NO_OPERATION)
+                      if !query.valid? || query.context.errors.any?
+                        # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
+                        { "errors" => query.static_errors.map(&:to_h) }
+                      else
+                        data_result
+                      end
+                    else
+                      result = {
+                        "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
+                      }
+
+                      if query.context.errors.any?
+                        error_result = query.context.errors.map(&:to_h)
+                        result["errors"] = error_result
+                      end
+
+                      result
+                    end
+                    if query.context.namespace?(:__query_result_extensions__)
+                      query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
+                    end
+                    # Get the Query::Result, not the Hash
+                    results[idx] = query.result
+                  end
+
+                  results
+                rescue Exception
+                  # TODO rescue at a higher level so it will catch errors in analysis, too
+                  # Assign values here so that the query's `@executed` becomes true
+                  queries.map { |q| q.result_values ||= {} }
+                  raise
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        # Call the before_ hooks of each query,
+        # Then yield if no errors.
+        # `call_hooks` takes care of appropriate cleanup.
+        def each_query_call_hooks(instrumenters, queries, i = 0)
+          if i >= queries.length
+            yield
+          else
+            query = queries[i]
+            call_hooks(instrumenters, query, :before_query, :after_query) {
+              each_query_call_hooks(instrumenters, queries, i + 1) {
+                yield
+              }
+            }
+          end
+        end
+
+        # Call each before hook, and if they all succeed, yield.
+        # If they don't all succeed, call after_ for each one that succeeded.
+        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
+          begin
+            successful = []
+            instrumenters.each do |instrumenter|
+              instrumenter.public_send(before_hook_name, object)
+              successful << instrumenter
+            end
+
+            # if any before hooks raise an exception, quit calling before hooks,
+            # but call the after hooks on anything that succeeded but also
+            # raise the exception that came from the before hook.
+          rescue GraphQL::ExecutionError => err
+            object.context.errors << err
+          rescue => e
+            raise call_after_hooks(successful, object, after_hook_name, e)
+          end
+
+          begin
+            yield # Call the user code
+          ensure
+            ex = call_after_hooks(successful, object, after_hook_name, nil)
+            raise ex if ex
+          end
+        end
+
+        def call_after_hooks(instrumenters, object, after_hook_name, ex)
+          instrumenters.reverse_each do |instrumenter|
+            begin
+              instrumenter.public_send(after_hook_name, object)
+            rescue => e
+              ex = e
+            end
+          end
+          ex
+        end
+      end
+
+      class ListResultFailedError < GraphQL::Error
+        def initialize(value:, path:, field:)
+          message = "Failed to build a GraphQL list result for field `#{field.path}` at path `#{path.join(".")}`.\n".dup
+
+          message << "Expected `#{value.inspect}` (#{value.class}) to implement `.each` to satisfy the GraphQL return type `#{field.type.to_type_signature}`.\n"
+
+          if field.connection?
+            message << "\nThis field was treated as a Relay-style connection; add `connection: false` to the `field(...)` to disable this behavior."
+          end
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/lazy/lazy_method_map.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'thread'
+begin
+  require 'concurrent'
+rescue LoadError
+  # no problem, we'll fallback to our own map
+end
+
+module GraphQL
+  module Execution
+    class Lazy
+      # {GraphQL::Schema} uses this to match returned values to lazy resolution methods.
+      # Methods may be registered for classes, they apply to its subclasses also.
+      # The result of this lookup is cached for future resolutions.
+      # Instances of this class are thread-safe.
+      # @api private
+      # @see {Schema#lazy?} looks up values from this map
+      class LazyMethodMap
+        def initialize(use_concurrent: defined?(Concurrent::Map))
+          @storage = use_concurrent ? Concurrent::Map.new : ConcurrentishMap.new
+        end
+
+        def initialize_copy(other)
+          @storage = other.storage.dup
+        end
+
+        # @param lazy_class [Class] A class which represents a lazy value (subclasses may also be used)
+        # @param lazy_value_method [Symbol] The method to call on this class to get its value
+        def set(lazy_class, lazy_value_method)
+          @storage[lazy_class] = lazy_value_method
+        end
+
+        # @param value [Object] an object which may have a `lazy_value_method` registered for its class or superclasses
+        # @return [Symbol, nil] The `lazy_value_method` for this object, or nil
+        def get(value)
+          @storage.compute_if_absent(value.class) { find_superclass_method(value.class) }
+        end
+
+        def each
+          @storage.each_pair { |k, v| yield(k, v) }
+        end
+
+        protected
+
+        attr_reader :storage
+
+        private
+
+        def find_superclass_method(value_class)
+          @storage.each_pair { |lazy_class, lazy_value_method|
+            return lazy_value_method if value_class < lazy_class
+          }
+          nil
+        end
+
+        # Mock the Concurrent::Map API
+        class ConcurrentishMap
+          extend Forwardable
+          # Technically this should be under the mutex too,
+          # but I know it's only used when the lock is already acquired.
+          def_delegators :@storage, :each_pair, :size
+
+          def initialize
+            @semaphore = Mutex.new
+            # Access to this hash must always be managed by the mutex
+            # since it may be modified at runtime
+            @storage = {}
+          end
+
+          def []=(key, value)
+            @semaphore.synchronize {
+              @storage[key] = value
+            }
+          end
+
+          def compute_if_absent(key)
+            @semaphore.synchronize {
+              @storage.fetch(key) { @storage[key] = yield }
+            }
+          end
+
+          def initialize_copy(other)
+            @semaphore = Mutex.new
+            @storage = other.copy_storage
+          end
+
+          protected
+
+          def copy_storage
+            @semaphore.synchronize {
+              @storage.dup
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/lazy.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "graphql/execution/lazy/lazy_method_map"
+
+module GraphQL
+  module Execution
+    # This wraps a value which is available, but not yet calculated, like a promise or future.
+    #
+    # Calling `#value` will trigger calculation & return the "lazy" value.
+    #
+    # This is an itty-bitty promise-like object, with key differences:
+    # - It has only two states, not-resolved and resolved
+    # - It has no error-catching functionality
+    # @api private
+    class Lazy
+      attr_reader :path, :field
+
+      # Create a {Lazy} which will get its inner value by calling the block
+      # @param path [Array<String, Integer>]
+      # @param field [GraphQL::Schema::Field]
+      # @param get_value_func [Proc] a block to get the inner value (later)
+      def initialize(path: nil, field: nil, &get_value_func)
+        @get_value_func = get_value_func
+        @resolved = false
+        @path = path
+        @field = field
+      end
+
+      # @return [Object] The wrapped value, calling the lazy block if necessary
+      def value
+        if !@resolved
+          @resolved = true
+          @value = begin
+            v = @get_value_func.call
+            if v.is_a?(Lazy)
+              v = v.value
+            end
+            v
+          rescue GraphQL::ExecutionError => err
+            err
+          end
+        end
+
+        # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
+        # (fewer clauses in a hot `case` block), but now it requires special handling here.
+        # I think it's still worth it for the performance win, but if the number of special
+        # cases grows, then maybe it's worth rethinking somehow.
+        if @value.is_a?(StandardError) && @value != GraphQL::Execution::SKIP
+          raise @value
+        else
+          @value
+        end
+      end
+
+      # @return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in `block`
+      def then
+        self.class.new {
+          yield(value)
+        }
+      end
+
+      # @param lazies [Array<Object>] Maybe-lazy objects
+      # @return [Lazy] A lazy which will sync all of `lazies`
+      def self.all(lazies)
+        self.new {
+          lazies.map { |l| l.is_a?(Lazy) ? l.value : l }
+        }
+      end
+
+      # This can be used for fields which _had no_ lazy results
+      # @api private
+      NullResult = Lazy.new(){}
+      NullResult.value
+    end
+  end
+end