graphql 2.0.20 → 2.0.22

data/lib/graphql/language/parser.y

@@ -284,7 +284,11 @@ rule
    | directive_definition
 
   schema_definition:
-      SCHEMA directives_list_opt LCURLY operation_type_definition_list RCURLY { result = make_node(:SchemaDefinition, position_source: val[0], definition_line: val[0][1], directives: val[1], **val[3]) }
+      SCHEMA directives_list_opt operation_type_definition_list_opt { result = make_node(:SchemaDefinition, position_source: val[0], definition_line: val[0][1], directives: val[1], **val[2]) }
+
+  operation_type_definition_list_opt:
+      /* none */ { result = {} }
+    | LCURLY operation_type_definition_list RCURLY { result = val[1] }
 
   operation_type_definition_list:
       operation_type_definition

data/lib/graphql/pagination/connection.rb

@@ -58,7 +58,7 @@ module GraphQL
       # @param arguments [Hash] The arguments to the field that returned the collection wrapped by this connection
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given and no `default_page_size` is set.
       # @param default_page_size [Integer, nil] A configured value to determine the result size when neither first or last are given.
-      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, default_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
         @parent = parent
         @context = context
@@ -71,14 +71,14 @@ module GraphQL
         @edge_class = edge_class || self.class::Edge
         # This is only true if the object was _initialized_ with an override
         # or if one is assigned later.
-        @has_max_page_size_override = max_page_size != :not_given
-        @max_page_size = if max_page_size == :not_given
+        @has_max_page_size_override = max_page_size != NOT_CONFIGURED
+        @max_page_size = if max_page_size == NOT_CONFIGURED
           nil
         else
           max_page_size
         end
-        @has_default_page_size_override = default_page_size != :not_given
-        @default_page_size = if default_page_size == :not_given
+        @has_default_page_size_override = default_page_size != NOT_CONFIGURED
+        @default_page_size = if default_page_size == NOT_CONFIGURED
           nil
         else
           default_page_size

data/lib/graphql/query/context.rb

@@ -91,8 +91,8 @@ module GraphQL
       end
 
       class ScopedContext
-        NO_PATH = [].freeze
-        NO_CONTEXT = {}.freeze
+        NO_PATH = GraphQL::EmptyObjects::EMPTY_ARRAY
+        NO_CONTEXT = GraphQL::EmptyObjects::EMPTY_HASH
 
         def initialize(query_context)
           @query_context = query_context
@@ -226,8 +226,9 @@ module GraphQL
           if key == :current_path
             current_path
           else
-            thread_info = Thread.current[:__graphql_runtime_info]
-            thread_info && thread_info[key]
+            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+              (query_runtime_state = current_runtime_state[@query]) &&
+              (query_runtime_state.public_send(key))
           end
         else
           # not found
@@ -236,11 +237,13 @@ module GraphQL
       end
 
       def current_path
-        thread_info = Thread.current[:__graphql_runtime_info]
-        path = thread_info &&
-          (result = thread_info[:current_result]) &&
+        current_runtime_state = Thread.current[:__graphql_runtime_info]
+        query_runtime_state = current_runtime_state && current_runtime_state[@query]
+
+        path = query_runtime_state &&
+          (result = query_runtime_state.current_result) &&
           (result.path)
-        if path && (rn = thread_info[:current_result_name])
+        if path && (rn = query_runtime_state.current_result_name)
           path = path.dup
           path.push(rn)
         end
@@ -259,8 +262,9 @@ module GraphQL
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (thread_info = Thread.current[:__graphql_runtime_info]) &&
-            thread_info[key]
+          (runtime = Thread.current[:__graphql_runtime_info]) &&
+            (query_runtime_state = runtime[@query]) &&
+            (query_runtime_state.public_send(key))
         elsif @scoped_context.key?(key)
           scoped_context[key]
         elsif @provided_values.key?(key)
@@ -276,8 +280,14 @@ module GraphQL
 
       def dig(key, *other_keys)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (thread_info = Thread.current[:__graphql_runtime_info]).key?(key) &&
-            thread_info.dig(key, *other_keys)
+          (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (query_runtime_state = current_runtime_state[@query]) &&
+            (obj = query_runtime_state.public_send(key)) &&
+            if other_keys.empty?
+              obj
+            else
+              obj.dig(*other_keys)
+            end
         elsif @scoped_context.key?(key)
           @scoped_context.dig(key, *other_keys)
         else

data/lib/graphql/query/null_context.rb

@@ -12,6 +12,9 @@ module GraphQL
       end
 
       class NullQuery
+        def after_lazy(value)
+          yield(value)
+        end
       end
 
       class NullSchema < GraphQL::Schema
@@ -24,7 +27,7 @@ module GraphQL
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = NullSchema
         @warden = NullWarden.new(
-          GraphQL::Filter.new,
+          GraphQL::Filter.new(silence_deprecation_warning: true),
           context: self,
           schema: @schema,
         )

data/lib/graphql/query.rb

@@ -87,7 +87,9 @@ module GraphQL
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
-      @filter = schema.default_filter.merge(except: except, only: only)
+      if only || except
+        merge_filters(except: except, only: only)
+      end
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
       @subscription_topic = subscription_topic
@@ -100,12 +102,16 @@ module GraphQL
 
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        context_tracers += [GraphQL::Backtrace::Tracer]
-        @tracers << GraphQL::Backtrace::Tracer
+        if schema.trace_class <= GraphQL::Tracing::LegacyTrace
+          context_tracers += [GraphQL::Backtrace::Tracer]
+          @tracers << GraphQL::Backtrace::Tracer
+        elsif !(current_trace.class <= GraphQL::Backtrace::Trace)
+          raise "Invariant: `backtrace: true` should have provided a trace class with Backtrace mixed in, but it didnt. (Found: #{current_trace.class.ancestors}). This is a bug in GraphQL-Ruby, please report it on GitHub."
+        end
       end
 
       if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
-        raise ArgumentError, "context[:tracers] and context[:backtrace] are not supported without `tracer_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
+        raise ArgumentError, "context[:tracers] are not supported without `trace_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
       end
 
 
@@ -147,11 +153,6 @@ module GraphQL
 
       @result_values = nil
       @executed = false
-
-      # TODO add a general way to define schema-level filters
-      if @schema.respond_to?(:visible?)
-        merge_filters(only: @schema.method(:visible?))
-      end
     end
 
     # If a document was provided to `GraphQL::Schema#execute` instead of the raw query string, we will need to get it from the document
@@ -318,8 +319,8 @@ module GraphQL
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}
     # @see {#possible_types} to apply filtering from `only` / `except`
-    def resolve_type(abstract_type, value = :__undefined__)
-      if value.is_a?(Symbol) && value == :__undefined__
+    def resolve_type(abstract_type, value = NOT_CONFIGURED)
+      if value.is_a?(Symbol) && value == NOT_CONFIGURED
         # Old method signature
         value = abstract_type
         abstract_type = nil
@@ -343,6 +344,7 @@ module GraphQL
       if @prepared_ast
         raise "Can't add filters after preparing the query"
       else
+        @filter ||= @schema.default_filter
         @filter = @filter.merge(only: only, except: except)
       end
       nil
@@ -357,6 +359,18 @@ module GraphQL
       schema.handle_or_reraise(context, err)
     end
 
+    def after_lazy(value, &block)
+      if !defined?(@runtime_instance)
+        @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
+      end
+
+      if @runtime_instance
+        @runtime_instance.minimal_after_lazy(value, &block)
+      else
+        @schema.after_lazy(value, &block)
+      end
+    end
+
     private
 
     def find_operation(operations, operation_name)

data/lib/graphql/schema/argument.rb

@@ -7,9 +7,7 @@ module GraphQL
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
       include GraphQL::Schema::Member::HasValidators
-      include GraphQL::Schema::FindInheritedValue::EmptyObjects
-
-      NO_DEFAULT = :__no_default__
+      include GraphQL::EmptyObjects
 
       # @return [String] the GraphQL name for this argument, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -20,8 +18,8 @@ module GraphQL
 
       # @param new_prepare [Method, Proc]
       # @return [Symbol] A method or proc to call to transform this value before sending it to field resolution method
-      def prepare(new_prepare = NO_DEFAULT)
-        if new_prepare != NO_DEFAULT
+      def prepare(new_prepare = NOT_CONFIGURED)
+        if new_prepare != NOT_CONFIGURED
           @prepare = new_prepare
         end
         @prepare
@@ -52,7 +50,7 @@ module GraphQL
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
       # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
@@ -104,8 +102,8 @@ module GraphQL
 
       # @param default_value [Object] The value to use when the client doesn't provide one
       # @return [Object] the value used when the client doesn't provide a value for this argument
-      def default_value(new_default_value = NO_DEFAULT)
-        if new_default_value != NO_DEFAULT
+      def default_value(new_default_value = NOT_CONFIGURED)
+        if new_default_value != NOT_CONFIGURED
           @default_value = new_default_value
         end
         @default_value
@@ -113,7 +111,7 @@ module GraphQL
 
       # @return [Boolean] True if this argument has a default value
       def default_value?
-        @default_value != NO_DEFAULT
+        @default_value != NOT_CONFIGURED
       end
 
       def replace_null_with_default?
@@ -200,8 +198,8 @@ module GraphQL
 
       def statically_coercible?
         return @statically_coercible if defined?(@statically_coercible)
-
-        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+        requires_parent_object = @prepare.is_a?(String) || @prepare.is_a?(Symbol) || @own_validators
+        @statically_coercible = !requires_parent_object
       end
 
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
@@ -266,7 +264,7 @@ module GraphQL
 
         # If this isn't lazy, then the block returns eagerly and assigns the result here
         # If it _is_ lazy, then we write the lazy to the hash, then update it later
-        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
+        argument_values[arg_key] = context.query.after_lazy(coerced_value) do |resolved_coerced_value|
           owner.validate_directive_argument(self, resolved_coerced_value)
           prepared_value = begin
             prepare_value(parent_object, resolved_coerced_value, context: context)
@@ -283,7 +281,7 @@ module GraphQL
           end
 
           maybe_loaded_value = loaded_value || prepared_value
-          context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
+          context.query.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
             # TODO code smell to access such a deeply-nested constant in a distant module
             argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
               value: resolved_loaded_value,
@@ -305,7 +303,7 @@ module GraphQL
           else
             load_method_owner.public_send(arg_load_method, coerced_value)
           end
-          context.schema.after_lazy(custom_loaded_value) do |custom_value|
+          context.query.after_lazy(custom_loaded_value) do |custom_value|
             if loads
               if type.list?
                 loaded_values = custom_value.each_with_index.map { |custom_val, idx|

data/lib/graphql/schema/build_from_definition.rb

@@ -21,6 +21,7 @@ module GraphQL
 
       # @api private
       module Builder
+        include GraphQL::EmptyObjects
         extend self
 
         def build(schema_superclass, document, default_resolve:, using: {}, relay:)
@@ -99,6 +100,16 @@ module GraphQL
               raise InvalidDocumentError.new("Specified subscription type \"#{schema_definition.subscription}\" not found in document.") unless types[schema_definition.subscription]
               subscription_root_type = types[schema_definition.subscription]
             end
+
+            if schema_definition.query.nil? &&
+                schema_definition.mutation.nil? &&
+                schema_definition.subscription.nil?
+              # This schema may have been given with directives only,
+              # check for defaults:
+              query_root_type = types['Query']
+              mutation_root_type = types['Mutation']
+              subscription_root_type = types['Subscription']
+            end
           else
             query_root_type = types['Query']
             mutation_root_type = types['Mutation']
@@ -107,6 +118,8 @@ module GraphQL
 
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
+          builder = self
+
           schema_class = Class.new(schema_superclass) do
             begin
               # Add these first so that there's some chance of resolving late-bound types
@@ -134,6 +147,7 @@ module GraphQL
 
             if schema_definition
               ast_node(schema_definition)
+              builder.build_directives(self, schema_definition, type_resolver)
             end
 
             using.each do |plugin, options|
@@ -361,8 +375,6 @@ module GraphQL
           end
         end
 
-        NO_DEFAULT_VALUE = {}.freeze
-
         def build_arguments(type_class, arguments, type_resolver)
           builder = self
 
@@ -370,7 +382,7 @@ module GraphQL
             default_value_kwargs = if !argument_defn.default_value.nil?
               { default_value: builder.build_default_value(argument_defn.default_value) }
             else
-              NO_DEFAULT_VALUE
+              EMPTY_HASH
             end
 
             type_class.argument(

data/lib/graphql/schema/enum_value.rb

@@ -25,19 +25,16 @@ module GraphQL
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
 
-      UNDEFINED_VALUE = Object.new.freeze
-      private_constant :UNDEFINED_VALUE
-
       attr_reader :graphql_name
 
       # @return [Class] The enum type that owns this value
       attr_reader :owner
 
-      def initialize(graphql_name, desc = nil, owner:, ast_node: nil, directives: nil, description: nil, value: UNDEFINED_VALUE, deprecation_reason: nil, &block)
+      def initialize(graphql_name, desc = nil, owner:, ast_node: nil, directives: nil, description: nil, value: NOT_CONFIGURED, deprecation_reason: nil, &block)
         @graphql_name = graphql_name.to_s
         GraphQL::NameValidator.validate!(@graphql_name)
         @description = desc || description
-        @value = value === UNDEFINED_VALUE ? @graphql_name : value
+        @value = value == NOT_CONFIGURED ? @graphql_name : value
         if deprecation_reason
           self.deprecation_reason = deprecation_reason
         end

data/lib/graphql/schema/field/connection_extension.rb

@@ -26,7 +26,7 @@ module GraphQL
           # rename some inputs to avoid conflicts inside the block
           maybe_lazy = value
           value = nil
-          context.schema.after_lazy(maybe_lazy) do |resolved_value|
+          context.query.after_lazy(maybe_lazy) do |resolved_value|
             value = resolved_value
             if value.is_a? GraphQL::ExecutionError
               # This isn't even going to work because context doesn't have ast_node anymore

data/lib/graphql/schema/field.rb

@@ -11,7 +11,7 @@ module GraphQL
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasValidators
       extend GraphQL::Schema::FindInheritedValue
-      include GraphQL::Schema::FindInheritedValue::EmptyObjects
+      include GraphQL::EmptyObjects
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
 
@@ -219,7 +219,7 @@ module GraphQL
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @fallback_value [Object] A fallback value if the method is not defined
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -235,7 +235,7 @@ module GraphQL
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
 
         @description = description
-        @type = @owner_type = @own_validators = @own_directives = @own_arguments = nil # these will be prepared later if necessary
+        @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary
 
         self.deprecation_reason = deprecation_reason
 
@@ -608,15 +608,16 @@ module GraphQL
           # The resolver _instance_ will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
-          if (arg_values = context[:current_arguments])
-            # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
-            using_arg_values = true
-            arg_values = arg_values.argument_values
-          else
-            arg_values = args
-            using_arg_values = false
-          end
           if args.size > 0
+            if (arg_values = context[:current_arguments])
+              # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
+              using_arg_values = true
+              arg_values = arg_values.argument_values
+            else
+              arg_values = args
+              using_arg_values = false
+            end
+
             args = context.warden.arguments(self)
             args.each do |arg|
               arg_key = arg.keyword
@@ -660,7 +661,7 @@ module GraphQL
 
         Schema::Validator.validate!(validators, application_object, query_ctx, args)
 
-        query_ctx.schema.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
+        query_ctx.query.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
           if is_authorized
             with_extensions(object, args, query_ctx) do |obj, ruby_kwargs|
               method_args = ruby_kwargs
@@ -684,7 +685,7 @@ module GraphQL
                 if hash_value == false
                   hash_value
                 else
-                  hash_value || (@fallback_value != :not_given ? @fallback_value : nil)
+                  hash_value || (@fallback_value != NOT_CONFIGURED ? @fallback_value : nil)
                 end
               elsif obj.respond_to?(resolver_method)
                 method_to_call = resolver_method
@@ -702,7 +703,7 @@ module GraphQL
                   inner_object[@method_sym]
                 elsif inner_object.key?(@method_str)
                   inner_object[@method_str]
-                elsif @fallback_value != :not_given
+                elsif @fallback_value != NOT_CONFIGURED
                   @fallback_value
                 else
                   nil
@@ -715,7 +716,7 @@ module GraphQL
                 else
                   inner_object.public_send(@method_sym)
                 end
-              elsif @fallback_value != :not_given
+              elsif @fallback_value != NOT_CONFIGURED
                 @fallback_value
               else
                 raise <<-ERR
@@ -832,7 +833,7 @@ ERR
           extended_args = extended[:args]
           memos = extended[:memos] || EMPTY_HASH
 
-          ctx.schema.after_lazy(value) do |resolved_value|
+          ctx.query.after_lazy(value) do |resolved_value|
             idx = 0
             @extensions.each do |ext|
               memo = memos[idx]

data/lib/graphql/schema/field_extension.rb

@@ -71,14 +71,11 @@ module GraphQL
           elsif inherited_extras
             inherited_extras
           else
-            NO_EXTRAS
+            GraphQL::EmptyObjects::EMPTY_ARRAY
           end
         end
       end
 
-      NO_EXTRAS = [].freeze
-      private_constant :NO_EXTRAS
-
       # Called when this extension is attached to a field.
       # The field definition may be extended during this method.
       # @return [void]

data/lib/graphql/schema/find_inherited_value.rb

@@ -2,17 +2,12 @@
 module GraphQL
   class Schema
     module FindInheritedValue
-      module EmptyObjects
-        EMPTY_HASH = {}.freeze
-        EMPTY_ARRAY = [].freeze
-      end
-
       def self.extended(child_cls)
-        child_cls.singleton_class.include(EmptyObjects)
+        child_cls.singleton_class.include(GraphQL::EmptyObjects)
       end
 
       def self.included(child_cls)
-        child_cls.include(EmptyObjects)
+        child_cls.include(GraphQL::EmptyObjects)
       end
 
       private

data/lib/graphql/schema/input_object.rb

@@ -211,7 +211,7 @@ module GraphQL
 
           arguments = coerce_arguments(nil, value, ctx)
 
-          ctx.schema.after_lazy(arguments) do |resolved_arguments|
+          ctx.query.after_lazy(arguments) do |resolved_arguments|
             if resolved_arguments.is_a?(GraphQL::Error)
               raise resolved_arguments
             else

data/lib/graphql/schema/member/has_arguments.rb

@@ -51,7 +51,7 @@ module GraphQL
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
                 argument = get_argument("#{arg_defn.graphql_name}")
-                (context || self.context).schema.after_lazy(values) do |values2|
+                (context || self.context).query.after_lazy(values) do |values2|
                   GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
                 end
               end
@@ -320,9 +320,11 @@ module GraphQL
         end
 
         def arguments_statically_coercible?
-          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
-
-          @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          if defined?(@arguments_statically_coercible) && !@arguments_statically_coercible.nil?
+            @arguments_statically_coercible
+          else
+            @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          end
         end
 
         module ArgumentClassAccessor
@@ -363,7 +365,7 @@ module GraphQL
           end
 
           def authorize_application_object(argument, id, context, loaded_application_object)
-            context.schema.after_lazy(loaded_application_object) do |application_object|
+            context.query.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
                 err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
                 load_application_object_failed(err)
@@ -371,7 +373,7 @@ module GraphQL
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
               maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.schema.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+              context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
                 if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
                   application_object_type, application_object = resolve_type_result
                 else
@@ -386,7 +388,7 @@ module GraphQL
                   # This object was loaded successfully
                   # and resolved to the right type,
                   # now apply the `.authorized?` class method if there is one
-                  context.schema.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                  context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
                     if authed
                       application_object
                     else
@@ -413,7 +415,7 @@ module GraphQL
           end
         end
 
-        NO_ARGUMENTS = {}.freeze
+        NO_ARGUMENTS =  GraphQL::EmptyObjects::EMPTY_HASH
         def own_arguments
           @own_arguments || NO_ARGUMENTS
         end

data/lib/graphql/schema/member/has_directives.rb

@@ -33,8 +33,6 @@ module GraphQL
           nil
         end
 
-        NO_DIRECTIVES = [].freeze
-
         def directives
           HasDirectives.get_directives(self, @own_directives, :directives)
         end
@@ -55,7 +53,7 @@ module GraphQL
               inherited_directives = if schema_member.superclass.respond_to?(directives_method)
                 get_directives(schema_member.superclass, schema_member.superclass.public_send(directives_method), directives_method)
               else
-                NO_DIRECTIVES
+                GraphQL::EmptyObjects::EMPTY_ARRAY
               end
               if inherited_directives.any? && directives
                 dirs = []
@@ -67,7 +65,7 @@ module GraphQL
               elsif inherited_directives.any?
                 inherited_directives
               else
-                NO_DIRECTIVES
+                GraphQL::EmptyObjects::EMPTY_ARRAY
               end
             when Module
               dirs = nil
@@ -82,9 +80,9 @@ module GraphQL
                 dirs ||= []
                 merge_directives(dirs, directives)
               end
-              dirs || NO_DIRECTIVES
+              dirs || GraphQL::EmptyObjects::EMPTY_ARRAY
             when HasDirectives
-              directives || NO_DIRECTIVES
+              directives || GraphQL::EmptyObjects::EMPTY_ARRAY
             else
               raise "Invariant: how could #{schema_member} not be a Class, Module, or instance of HasDirectives?"
             end