graphql 1.2.6 → 1.3.0

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

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class SerialExecution
       module ValueResolution
-        def self.resolve(parent_type, field_defn, field_type, value, irep_nodes, query_ctx)
+        def self.resolve(parent_type, field_defn, field_type, value, selection, query_ctx)
           if value.nil? || value.is_a?(GraphQL::ExecutionError)
             if field_type.kind.non_null?
-              raise GraphQL::InvalidNullError.new(parent_type.name, field_defn.name, value)
+              if value.nil?
+                type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
+                query_ctx.schema.type_error(type_error, query_ctx)
+              end
+              raise GraphQL::Query::Executor::PropagateNull
             else
               nil
             end
@@ -17,17 +22,25 @@ module GraphQL
               field_type.coerce_result(value, query_ctx.query.warden)
             when GraphQL::TypeKinds::LIST
               wrapped_type = field_type.of_type
-              result = value.each_with_index.map do |inner_value, index|
-                inner_ctx = query_ctx.spawn(path: query_ctx.path + [index], irep_node: query_ctx.irep_node)
-                inner_result = resolve(
+              result = []
+              i = 0
+              value.each do |inner_value|
+                inner_ctx = query_ctx.spawn(
+                  key: i,
+                  selection: selection,
+                  parent_type: wrapped_type,
+                  field: field_defn,
+                )
+
+                result << resolve(
                   parent_type,
                   field_defn,
                   wrapped_type,
                   inner_value,
-                  irep_nodes,
+                  selection,
                   inner_ctx,
                 )
-                inner_result
+                i += 1
               end
               result
             when GraphQL::TypeKinds::NON_NULL
@@ -37,14 +50,14 @@ module GraphQL
                 field_defn,
                 wrapped_type,
                 value,
-                irep_nodes,
+                selection,
                 query_ctx,
               )
             when GraphQL::TypeKinds::OBJECT
               query_ctx.execution_strategy.selection_resolution.resolve(
                 value,
                 field_type,
-                irep_nodes,
+                selection,
                 query_ctx
               )
             when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
@@ -53,14 +66,16 @@ module GraphQL
               possible_types = query.possible_types(field_type)
 
               if !possible_types.include?(resolved_type)
-                raise GraphQL::UnresolvedTypeError.new(irep_nodes.first.definition_name, field_type, parent_type, resolved_type, possible_types)
+                type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+                query.schema.type_error(type_error, query_ctx)
+                raise GraphQL::Query::Executor::PropagateNull
               else
                 resolve(
                   parent_type,
                   field_defn,
                   resolved_type,
                   value,
-                  irep_nodes,
+                  selection,
                   query_ctx,
                 )
               end

data/lib/graphql/query/variable_validation_error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class VariableValidationError < GraphQL::ExecutionError

data/lib/graphql/query/variables.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.

data/lib/graphql/relay.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'base64'
 
 require 'graphql/relay/page_info'

data/lib/graphql/relay/array_connection.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     class ArrayConnection < BaseConnection
       def cursor_from_node(item)
         idx = starting_offset + sliced_nodes.find_index(item) + 1
-        Base64.strict_encode64(idx.to_s)
+        encode(idx.to_s)
       end
 
       def has_next_page
@@ -35,7 +36,7 @@ module GraphQL
       end
 
       def index_from_cursor(cursor)
-        Base64.decode64(cursor).to_i
+        decode(cursor).to_i
       end
 
       def starting_offset

data/lib/graphql/relay/base_connection.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     # Subclasses must implement:
@@ -15,13 +16,13 @@ module GraphQL
       CURSOR_SEPARATOR = "---"
 
       # Map of collection class names -> connection_classes
-      # eg {"Array" => ArrayConnection}
+      # eg `{"Array" => ArrayConnection}`
       CONNECTION_IMPLEMENTATIONS = {}
 
       class << self
         # Find a connection implementation suitable for exposing `nodes`
         #
-        # @param [Object] A collection of nodes (eg, Array, AR::Relation)
+        # @param nodes [Object] A collection of nodes (eg, Array, AR::Relation)
         # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
         def connection_for_nodes(nodes)
           # Check for class _names_ because classes can be redefined in Rails development
@@ -39,8 +40,8 @@ module GraphQL
 
         # Add `connection_class` as the connection wrapper for `nodes_class`
         # eg, `RelationConnection` is the implementation for `AR::Relation`
-        # @param [Class] A class representing a collection (eg, Array, AR::Relation)
-        # @param [Class] A class implementing Connection methods
+        # @param nodes_class [Class] A class representing a collection (eg, Array, AR::Relation)
+        # @param connection_class [Class] A class implementing Connection methods
         def register_connection_implementation(nodes_class, connection_class)
           CONNECTION_IMPLEMENTATIONS[nodes_class.name] = connection_class
         end
@@ -49,17 +50,28 @@ module GraphQL
       attr_reader :nodes, :arguments, :max_page_size, :parent, :field
 
       # Make a connection, wrapping `nodes`
-      # @param [Object] The collection of nodes
-      # @param Query arguments
-      # @param field [Object] The underlying field
+      # @param nodes [Object] The collection of nodes
+      # @param arguments [GraphQL::Query::Arguments] Query arguments
+      # @param field [GraphQL::Field] The underlying field
       # @param max_page_size [Int] The maximum number of results to return
       # @param parent [Object] The object which this collection belongs to
-      def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil)
+      # @param context [GraphQL::Query::Context] The context from the field being resolved
+      def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
         @nodes = nodes
         @arguments = arguments
         @max_page_size = max_page_size
         @field = field
         @parent = parent
+        @context = context
+        @encoder = context ? @context.schema.cursor_encoder : GraphQL::Schema::Base64Encoder
+      end
+
+      def encode(data)
+        @encoder.encode(data, nonce: true)
+      end
+
+      def decode(data)
+        @encoder.decode(data, nonce: true)
       end
 
       # Provide easy access to provided arguments:

data/lib/graphql/relay/connection_field.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     # Provided a GraphQL field which returns a collection of nodes,

data/lib/graphql/relay/connection_resolve.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     class ConnectionResolve
@@ -9,8 +10,20 @@ module GraphQL
 
       def call(obj, args, ctx)
         nodes = @underlying_resolve.call(obj, args, ctx)
+        if ctx.schema.lazy?(nodes)
+          @field.prepare_lazy(nodes, args, ctx).then { |resolved_nodes|
+            build_connection(resolved_nodes, args, obj, ctx)
+          }
+        else
+          build_connection(nodes, args, obj, ctx)
+        end
+      end
+
+      private
+
+      def build_connection(nodes, args, parent, ctx)
         connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
-        connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: obj)
+        connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
       end
     end
   end

data/lib/graphql/relay/connection_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     module ConnectionType

data/lib/graphql/relay/edge.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     # Mostly an internal concern.

data/lib/graphql/relay/edge_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     module EdgeType

data/lib/graphql/relay/global_id_resolve.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     class GlobalIdResolve

data/lib/graphql/relay/mutation.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     # Define a Relay mutation:
@@ -181,6 +182,18 @@ module GraphQL
             mutation_result = nil
           end
 
+          if ctx.schema.lazy?(mutation_result)
+            @mutation.field.prepare_lazy(mutation_result, args, ctx).then { |inner_obj|
+              build_result(inner_obj, args)
+            }
+          else
+            build_result(mutation_result, args)
+          end
+        end
+
+        private
+
+        def build_result(mutation_result, args)
           if @wrap_result
             @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
           else

data/lib/graphql/relay/node.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     # Helpers for working with Relay-specific Node objects.

data/lib/graphql/relay/page_info.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     # Wrap a Connection and expose its page info

data/lib/graphql/relay/relation_connection.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Relay
     # A connection implementation to expose SQL collection objects.
@@ -11,7 +12,7 @@ module GraphQL
           raise("Can't generate cursor, item not found in connection: #{item}")
         else
           offset = starting_offset + item_index + 1
-          Base64.strict_encode64(offset.to_s)
+          encode(offset.to_s)
         end
       end
 
@@ -36,7 +37,7 @@ module GraphQL
       end
 
       def offset_from_cursor(cursor)
-        Base64.decode64(cursor).to_i
+        decode(cursor).to_i
       end
 
       def starting_offset

data/lib/graphql/runtime_type_error.rb

@@ -0,0 +1,4 @@
+module GraphQL
+  class RuntimeTypeError < GraphQL::Error
+  end
+end

data/lib/graphql/scalar_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # # GraphQL::ScalarType
   #
@@ -45,7 +46,7 @@ module GraphQL
     def validate_non_null_input(value, warden)
       result = Query::InputValidationResult.new
       if coerce_non_null_input(value).nil?
-        result.add_problem("Could not coerce value #{JSON.generate(value, quirks_mode: true)} to #{name}")
+        result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{name}")
       end
       result
     end

data/lib/graphql/schema.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+require "graphql/schema/base_64_encoder"
 require "graphql/schema/catchall_middleware"
+require "graphql/schema/default_type_error"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/instrumented_field_map"
 require "graphql/schema/middleware_chain"
@@ -51,12 +54,14 @@ module GraphQL
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
-      :orphan_types, :resolve_type,
+      :orphan_types, :resolve_type, :type_error,
       :object_from_id, :id_from_object,
+      :cursor_encoder,
       directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m  }},
       instrument: -> (schema, type, instrumenter) { schema.instrumenters[type] << instrumenter },
       query_analyzer: ->(schema, analyzer) { schema.query_analyzers << analyzer },
-      middleware: ->(schema, middleware) { schema.middleware << middleware },
+      middleware: ->(schema, middleware) { schema.user_middleware << middleware },
+      lazy_resolve: ->(schema, lazy_class, lazy_value_method) { schema.lazy_methods.set(lazy_class, lazy_value_method) },
       rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block)}
 
     attr_accessor \
@@ -64,7 +69,14 @@ module GraphQL
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
       :orphan_types, :directives,
-      :query_analyzers, :middleware, :instrumenters
+      :query_analyzers, :user_middleware, :instrumenters, :lazy_methods,
+      :cursor_encoder
+
+    class << self
+      attr_accessor :default_execution_strategy
+    end
+
+    self.default_execution_strategy = GraphQL::Execution::Execute
 
     BUILT_IN_TYPES = Hash[[INT_TYPE, STRING_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, ID_TYPE].map{ |type| [type.name, type] }]
     DIRECTIVES = [GraphQL::Directive::IncludeDirective, GraphQL::Directive::SkipDirective, GraphQL::Directive::DeprecatedDirective]
@@ -72,28 +84,51 @@ module GraphQL
 
     attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
 
-    # @!attribute [r] middleware
-    #   @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
-
-    # @param query [GraphQL::ObjectType]  the query root for the schema
-    # @param mutation [GraphQL::ObjectType] the mutation root for the schema
-    # @param subscription [GraphQL::ObjectType] the subscription root for the schema
-    # @param max_depth [Integer] maximum query nesting (if it's greater, raise an error)
-    # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
     def initialize
       @orphan_types = []
       @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
-      @middleware = []
+      @user_middleware = []
       @query_analyzers = []
       @resolve_type_proc = nil
       @object_from_id_proc = nil
       @id_from_object_proc = nil
+      @type_error_proc = DefaultTypeError
       @instrumenters = Hash.new { |h, k| h[k] = [] }
+      @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
+      @cursor_encoder = Base64Encoder
       # Default to the built-in execution strategy:
-      @query_execution_strategy = GraphQL::Query::SerialExecution
-      @mutation_execution_strategy = GraphQL::Query::SerialExecution
-      @subscription_execution_strategy = GraphQL::Query::SerialExecution
+      @query_execution_strategy = self.class.default_execution_strategy
+      @mutation_execution_strategy = self.class.default_execution_strategy
+      @subscription_execution_strategy = self.class.default_execution_strategy
+    end
+
+    def initialize_copy(other)
+      super
+      @orphan_types = other.orphan_types.dup
+      @directives = other.directives.dup
+      @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
+      @user_middleware = other.user_middleware.dup
+      @middleware = nil
+      @query_analyzers = other.query_analyzers.dup
+
+      @possible_types = GraphQL::Schema::PossibleTypes.new(self)
+
+      @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
+      other.lazy_methods.each { |lazy_class, lazy_method| @lazy_methods.set(lazy_class, lazy_method) }
+
+      @instrumenters = Hash.new { |h, k| h[k] = [] }
+      other.instrumenters.each do |key, insts|
+        @instrumenters[key].concat(insts)
+      end
+
+      if other.rescues?
+        @rescue_middleware = other.rescue_middleware
+      end
+
+      # This will be rebuilt when it's requested
+      # or during a later `define` call
+      @types = nil
     end
 
     def rescue_from(*args, &block)
@@ -107,12 +142,11 @@ module GraphQL
     def define(**kwargs, &block)
       super
       ensure_defined
-      all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
-      @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
-      build_instrumented_field_map
+      build_types_map
       # Assert that all necessary configs are present:
       validation_error = Validation.validate(self)
       validation_error && raise(NotImplementedError, validation_error)
+      build_instrumented_field_map
       nil
     end
 
@@ -127,10 +161,11 @@ module GraphQL
       end
     end
 
-
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
-    attr_reader :types
+    def types
+      @types ||= build_types_map
+    end
 
     # Execute a query on itself.
     # See {Query#initialize} for arguments.
@@ -240,6 +275,35 @@ module GraphQL
       @object_from_id_proc = new_proc
     end
 
+    # When we encounter a type error during query execution, we call this hook.
+    #
+    # You can use this hook to write a log entry,
+    # add a {GraphQL::ExecutionError} to the response (with `ctx.add_error`)
+    # or raise an exception and halt query execution.
+    #
+    # @example A `nil` is encountered by a non-null field
+    #   type_error ->(err, query_ctx) {
+    #     err.is_a?(GraphQL::InvalidNullError) # => true
+    #   }
+    #
+    # @example An object doesn't resolve to one of a {UnionType}'s members
+    #   type_error ->(err, query_ctx) {
+    #     err.is_a?(GraphQL::UnresolvedTypeError) # => true
+    #   }
+    #
+    # @see {DefaultTypeError} is the default behavior.
+    # @param err [GraphQL::TypeError] The error encountered during execution
+    # @param ctx [GraphQL::Query::Context] The context for the field where the error occurred
+    # @return void
+    def type_error(err, ctx)
+      @type_error_proc.call(err, ctx)
+    end
+
+    # @param new_proc [#call] A new callable for handling type errors during execution
+    def type_error=(new_proc)
+      @type_error_proc = new_proc
+    end
+
     # Get a unique identifier from this object
     # @param object [Any] An application object
     # @param type [GraphQL::BaseType] The current type definition
@@ -275,20 +339,46 @@ module GraphQL
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
     class InvalidDocumentError < Error; end;
 
-    private
+    # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
+    def lazy_method_name(obj)
+      @lazy_methods.get(obj)
+    end
+
+    # @return [Boolean] True if this object should be lazily resolved
+    def lazy?(obj)
+      !!lazy_method_name(obj)
+    end
+
+    # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
+    def middleware
+      @middleware ||= if @rescue_middleware
+        [@rescue_middleware].concat(@user_middleware)
+      else
+        @user_middleware
+      end
+    end
+
+    protected
+
+    def rescues?
+      !!@rescue_middleware
+    end
 
     # Lazily create a middleware and add it to the schema
     # (Don't add it if it's not used)
     def rescue_middleware
-      @rescue_middleware ||= begin
-        middleware = GraphQL::Schema::RescueMiddleware.new
-        @middleware << middleware
-        middleware
-      end
+      @rescue_middleware ||= GraphQL::Schema::RescueMiddleware.new
     end
 
+    private
+
     def build_instrumented_field_map
       @instrumented_field_map = InstrumentedFieldMap.new(self, @instrumenters[:field])
     end
+
+    def build_types_map
+      all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
+      @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
+    end
   end
 end