graphql 1.2.6 → 1.3.0

data/lib/graphql/execution/lazy.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require "graphql/execution/lazy/lazy_method_map"
+require "graphql/execution/lazy/resolve"
+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
+    class Lazy
+      # Traverse `val`, lazily resolving any values along the way
+      # @param val [Object] A data structure containing mixed plain values and `Lazy` instances
+      # @return void
+      def self.resolve(val)
+        Resolve.resolve(val)
+      end
+
+      # Create a {Lazy} which will get its inner value by calling the block
+      # @param target [Object]
+      # @param method_name [Symbol]
+      # @param get_value_func [Proc] a block to get the inner value (later)
+      def initialize(target = nil, method_name = nil, &get_value_func)
+        if block_given?
+          @get_value_func = get_value_func
+        else
+          @target = target
+          @method_name = method_name
+        end
+        @resolved = false
+      end
+
+      # @return [Object] The wrapped value, calling the lazy block if necessary
+      def value
+        if !@resolved
+          @resolved = true
+          if @get_value_func
+            @value = @get_value_func.call
+          else
+            @value = @target.public_send(@method_name)
+          end
+        end
+        @value
+      rescue GraphQL::ExecutionError => err
+        @resolved = true
+        @value = err
+      end
+
+      # @return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in `block`
+      def then(&block)
+        self.class.new {
+          next_val = block.call(value)
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+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.
+      class LazyMethodMap
+        def initialize
+          @storage = Hash.new do |h, value_class|
+            registered_superclass = h.each_key.find { |lazy_class| value_class < lazy_class }
+            if registered_superclass.nil?
+              h[value_class] = nil
+            else
+              h[value_class] = h[registered_superclass]
+            end
+          end
+        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[value.class]
+        end
+
+        def each
+          @storage.each { |k, v| yield(k,v) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class Lazy
+      # Helpers for dealing with data structures containing {Lazy} instances
+      module Resolve
+        # Mutate `value`, replacing {Lazy} instances in place with their resolved values
+        # @return [void]
+        def self.resolve(value)
+          lazies = resolve_in_place(value)
+          deep_sync(lazies)
+        end
+
+        def self.resolve_in_place(value)
+          lazies = []
+
+          each_lazy(value) do |field_result|
+            inner_lazy = field_result.value.then do |inner_v|
+              field_result.value = inner_v
+              resolve_in_place(inner_v)
+            end
+            lazies.push(inner_lazy)
+          end
+
+          Lazy.new { lazies.map(&:value) }
+        end
+
+        # If `value` is a collection, call `block`
+        # with any {Lazy} instances in the collection
+        # @return [void]
+        def self.each_lazy(value, &block)
+          case value
+          when SelectionResult
+            value.each do |key, field_result|
+              each_lazy(field_result, &block)
+            end
+          when Array
+            value.each do |field_result|
+              each_lazy(field_result, &block)
+            end
+          when FieldResult
+            field_value = value.value
+            if field_value.is_a?(Lazy)
+              yield(value)
+            else
+              each_lazy(field_value, &block)
+            end
+          end
+        end
+
+        # Traverse `val`, triggering resolution for each {Lazy}.
+        # These {Lazy}s are expected to mutate their owner data structures
+        # during resolution! (They're created with the `.then` calls in `resolve_in_place`).
+        # @return [void]
+        def self.deep_sync(val)
+          case val
+          when Lazy
+            deep_sync(val.value)
+          when Array
+            val.each { |v| deep_sync(v.value) }
+          when Hash
+            val.each { |k, v| deep_sync(v.value) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/selection_result.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # A set of key-value pairs suitable for a GraphQL response.
+    class SelectionResult
+      def initialize
+        @storage = {}
+        @owner = nil
+        @invalid_null = false
+      end
+
+      # @param key [String] The name for this value in the result
+      # @param field_result [FieldResult] The result for this field
+      def set(key, field_result)
+        @storage[key] = field_result
+      end
+
+      # @param key [String] The name of an already-defined result
+      # @return [FieldResult] The result for this field
+      def fetch(key)
+        @storage.fetch(key)
+      end
+
+      # Visit each key-result pair in this result
+      def each
+        @storage.each do |key, field_res|
+          yield(key, field_res)
+        end
+      end
+
+      # @return [Hash] A plain Hash representation of this result
+      def to_h
+        if @invalid_null
+          nil
+        else
+          flatten(self)
+        end
+      end
+
+      # A field has been unexpectedly nullified.
+      # Tell the owner {FieldResult} if it is present.
+      # Record {#invalid_null} in case an owner is added later.
+      def propagate_null
+        if @owner
+          @owner.value = GraphQL::Execution::Execute::PROPAGATE_NULL
+        end
+        @invalid_null = true
+      end
+
+      # @return [Boolean] True if this selection has been nullified by a null child
+      def invalid_null?
+        @invalid_null
+      end
+
+      # @param field_result [FieldResult] The field that this selection belongs to (used for propagating nulls)
+      def owner=(field_result)
+        if @owner
+          raise("Can't change owners of SelectionResult")
+        else
+          @owner = field_result
+        end
+      end
+
+      private
+
+      def flatten(obj)
+        case obj
+        when SelectionResult
+          flattened = {}
+          obj.each do |key, val|
+            flattened[key] = flatten(val)
+          end
+          flattened
+        when Array
+          obj.map { |v| flatten(v) }
+        when FieldResult
+          flatten(obj.value)
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/typecast.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Execution
     # GraphQL object `{value, current_type}` can be cast to `potential_type` when:
@@ -12,10 +13,9 @@ module GraphQL
       #
       # This is used for checking whether fragments apply to an object.
       #
-      # @param [Object] the value which GraphQL is currently exposing
-      # @param [GraphQL::BaseType] the type which GraphQL is using for `value` now
-      # @param [GraphQL::BaseType] can `value` be exposed using this type?
-      # @param [GraphQL::Query::Context] the context for the current query
+      # @param current_type [GraphQL::BaseType] the type which GraphQL is using now
+      # @param potential_type [GraphQL::BaseType] can this type be used from here?
+      # @param query_ctx [GraphQL::Query::Context] the context for the current query
       # @return [Boolean] true if `value` be evaluated as a `potential_type`
       def self.compatible?(current_type, potential_type, query_ctx)
         if current_type == potential_type

data/lib/graphql/execution_error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # If a field's resolve function returns a {ExecutionError},
   # the error will be inserted into the response's `"errors"` key

data/lib/graphql/field.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "graphql/field/resolve"
 
 module GraphQL
@@ -121,46 +122,65 @@ module GraphQL
   class Field
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :name, :description, :deprecation_reason,
-      :resolve, :type, :arguments,
+      :resolve, :lazy_resolve,
+      :type, :arguments,
       :property, :hash_key, :complexity, :mutation,
       :relay_node_field,
       argument: GraphQL::Define::AssignArgument
 
-
-    attr_accessor :name, :deprecation_reason, :description, :property, :hash_key, :mutation, :arguments, :complexity
-
-    # @return [Boolean] True if this is the Relay find-by-id field
-    attr_accessor :relay_node_field
-
     ensure_defined(
       :name, :deprecation_reason, :description, :description=, :property, :hash_key, :mutation, :arguments, :complexity,
-      :resolve, :resolve=, :type, :type=, :name=, :property=, :hash_key=,
+      :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc,
+      :type, :type=, :name=, :property=, :hash_key=,
       :relay_node_field,
     )
 
-    # @!attribute [r] resolve_proc
-    #   @return [<#call(obj, args,ctx)>] A proc-like object which can be called to return the field's value
+    # @return [Boolean] True if this is the Relay find-by-id field
+    attr_accessor :relay_node_field
+
+    # @return [<#call(obj, args, ctx)>] A proc-like object which can be called to return the field's value
     attr_reader :resolve_proc
 
-    # @!attribute name
-    #   @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
+    # @return [<#call(obj, args, ctx)>] A proc-like object which can be called trigger a lazy resolution
+    attr_reader :lazy_resolve_proc
+
+    # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
+    attr_accessor :name
+
+    # @return [String, nil] The client-facing description of this field
+    attr_accessor :description
+
+    # @return [String, nil] The client-facing reason why this field is deprecated (if present, the field is deprecated)
+    attr_accessor :deprecation_reason
+
+    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
+    attr_accessor :arguments
 
-    # @!attribute arguments
-    #   @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
+    # @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
+    attr_accessor :mutation
 
-    # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
+    # @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `->(query_ctx, args, child_complexity) { } # Numeric`
+    attr_accessor :complexity
 
-    # @!attribute complexity
-    #   @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `->(query_ctx, args, child_complexity) { } # Numeric`
+    # @return [Symbol, nil] The method to call on `obj` to return this field (overrides {#name} if present)
+    attr_accessor :property
+
+    # @return [Object, nil] The key to access with `obj.[]` to resolve this field (overrides {#name} if present)
+    attr_accessor :hash_key
 
     def initialize
       @complexity = 1
       @arguments = {}
       @resolve_proc = build_default_resolver
+      @lazy_resolve_proc = DefaultLazyResolve
       @relay_node_field = false
     end
 
+    def initialize_copy(other)
+      super
+      @arguments = other.arguments.dup
+    end
+
     # Get a value for this field
     # @example resolving a field value
     #   field.resolve(obj, args, ctx)
@@ -217,10 +237,40 @@ module GraphQL
       "<Field name:#{name || "not-named"} desc:#{description} resolve:#{resolve_proc}>"
     end
 
+    # If {#resolve} returned and object which should be handled lazily,
+    # this method will be called later force the object to return its value.
+    # @param obj [Object] The {#resolve}-provided object, registered with {Schema#lazy_resolve}
+    # @param args [GraphQL::Query::Arguments] Arguments to this field
+    # @param ctx [GraphQL::Query::Context] Context for this field
+    # @return [Object] The result of calling the registered method on `obj`
+    def lazy_resolve(obj, args, ctx)
+      @lazy_resolve_proc.call(obj, args, ctx)
+    end
+
+    # Assign a new resolve proc to this field. Used for {#lazy_resolve}
+    def lazy_resolve=(new_lazy_resolve_proc)
+      @lazy_resolve_proc = new_lazy_resolve_proc
+    end
+
+    # Prepare a lazy value for this field. It may be `then`-ed and resolved later.
+    # @return [GraphQL::Execution::Lazy] A lazy wrapper around `obj` and its registered method name
+    def prepare_lazy(obj, args, ctx)
+      GraphQL::Execution::Lazy.new {
+        lazy_resolve(obj, args, ctx)
+      }
+    end
+
     private
 
     def build_default_resolver
       GraphQL::Field::Resolve.create_proc(self)
     end
+
+    module DefaultLazyResolve
+      def self.call(obj, args, ctx)
+        method_name = ctx.schema.lazy_method_name(obj)
+        obj.public_send(method_name)
+      end
+    end
   end
 end

data/lib/graphql/field/resolve.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Field
     # Create resolve procs ahead of time based on a {GraphQL::Field}'s `name`, `property`, and `hash_key` configuration.

data/lib/graphql/float_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 GraphQL::FLOAT_TYPE = GraphQL::ScalarType.define do
   name "Float"
   description "Represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point)."

data/lib/graphql/id_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 GraphQL::ID_TYPE = GraphQL::ScalarType.define do
   name "ID"
   description "Represents a unique identifier that is Base64 obfuscated. It is often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"VXNlci0xMA==\"`) or integer (such as `4`) input value will be accepted as an ID."

data/lib/graphql/input_object_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # {InputObjectType}s are key-value inputs for fields.
   #
@@ -44,6 +45,11 @@ module GraphQL
       @arguments = {}
     end
 
+    def initialize_copy(other)
+      super
+      @arguments = other.arguments.dup
+    end
+
     def kind
       GraphQL::TypeKinds::INPUT_OBJECT
     end

data/lib/graphql/int_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 GraphQL::INT_TYPE = GraphQL::ScalarType.define do
   name "Int"
   description "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1."