graphql 2.5.11 → 2.6.10

data/lib/graphql/schema/visibility.rb

@@ -8,11 +8,17 @@ module GraphQL
     # Use this plugin to make some parts of your schema hidden from some viewers.
     #
     class Visibility
+      class TypeConfigurationError < GraphQL::Error
+        def initialize(config_message, config_str)
+          message = "GraphQL::Schema::Visibility already preloaded, but #{config_message} added to the schema. Move this `#{config_str}` configuration above `use(GraphQL::Schema::Visibility)"
+          super(message)
+        end
+      end
       # @param schema [Class<GraphQL::Schema>]
       # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
-      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?`)
+      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
       # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
-      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? Rails.env.production? : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging? || nil) : false), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
           ctx.freeze
@@ -20,7 +26,7 @@ module GraphQL
         schema.visibility = self.new(schema, dynamic: dynamic, preload: preload, profiles: profiles, migration_errors: migration_errors)
       end
 
-      def initialize(schema, dynamic:, preload:, profiles:, migration_errors:)
+      def initialize(schema, dynamic:, preload:, profiles:, migration_errors:, configuration_inherited: false)
         @schema = schema
         schema.use_visibility_profile = true
         schema.visibility_profile_class = if migration_errors
@@ -40,6 +46,7 @@ module GraphQL
         @types = nil
         @all_references = nil
         @loaded_all = false
+        @configuration_inherited = configuration_inherited
         if preload
           self.preload
         end
@@ -94,6 +101,7 @@ module GraphQL
         # Root types may have been nil:
         types_to_visit.compact!
         ensure_all_loaded(types_to_visit)
+        @cached_profiles.clear
         @profiles.each do |profile_name, example_ctx|
           prof = profile_for(example_ctx)
           prof.preload
@@ -102,41 +110,27 @@ module GraphQL
 
       # @api private
       def query_configured(query_type)
-        if @preload
-          ensure_all_loaded([query_type])
-        end
+        require_if_preloaded("a query type was", "query(...)")
       end
 
       # @api private
       def mutation_configured(mutation_type)
-        if @preload
-          ensure_all_loaded([mutation_type])
-        end
+        require_if_preloaded("a mutation type was", "mutation(...)")
       end
 
       # @api private
       def subscription_configured(subscription_type)
-        if @preload
-          ensure_all_loaded([subscription_type])
-        end
+        require_if_preloaded("a mutation type was", "subscription(...)")
       end
 
       # @api private
       def orphan_types_configured(orphan_types)
-        if @preload
-          ensure_all_loaded(orphan_types)
-        end
+        require_if_preloaded("orphan types were", "orphan_types(...)")
       end
 
       # @api private
       def introspection_system_configured(introspection_system)
-        if @preload
-          introspection_types = [
-            *@schema.introspection_system.types.values,
-            *@schema.introspection_system.entry_points.map { |ep| ep.type.unwrap },
-          ]
-          ensure_all_loaded(introspection_types)
-        end
+        require_if_preloaded("custom introspection was", "introspection(...)")
       end
 
       # Make another Visibility for `schema` based on this one
@@ -148,7 +142,8 @@ module GraphQL
           dynamic: @dynamic,
           preload: @preload,
           profiles: @profiles,
-          migration_errors: @migration_errors
+          migration_errors: @migration_errors,
+          configuration_inherited: true,
         )
       end
 
@@ -191,11 +186,24 @@ module GraphQL
         if refresh
           @top_level_profile = nil
         end
-        @top_level_profile ||= @schema.visibility_profile_class.new(context: Query::NullContext.instance, schema: @schema, visibility: self)
+        @top_level_profile ||= @schema.visibility_profile_class.new(context: @schema.null_context, schema: @schema, visibility: self)
       end
 
       private
 
+      def require_if_preloaded(config_message, config_code)
+        case @preload
+        when false
+          # Rails.env wasn't defined, so this won't try to preload unless manually set to true
+        when true, nil
+          if @configuration_inherited
+            preload
+          else
+            raise TypeConfigurationError.new(config_message, config_code)
+          end
+        end
+      end
+
       def ensure_all_loaded(types_to_visit)
         while (type = types_to_visit.shift)
           if type.kind.fields? && @preloaded_types.add?(type)

data/lib/graphql/schema/wrapper.rb

@@ -13,12 +13,22 @@ module GraphQL
       end
 
       def unwrap
-        @of_type.unwrap
+        @unwrapped ||= @of_type.unwrap
+      end
+
+      def freeze
+        unwrap
+        to_type_signature
+        super
       end
 
       def ==(other)
         self.class == other.class && of_type == other.of_type
       end
+
+      def deconstruct_keys(_keys)
+        { of_type: of_type }
+      end
     end
   end
 end

data/lib/graphql/schema.rb

@@ -330,10 +330,16 @@ module GraphQL
         find_inherited_value(:plugins, EMPTY_ARRAY) + own_plugins
       end
 
+      attr_writer :null_context
+
+      def null_context
+        @null_context || GraphQL::Query::NullContext.instance
+      end
+
       # Build a map of `{ name => type }` and return it
       # @return [Hash<String => Class>] A dictionary of type classes by their GraphQL name
       # @see get_type Which is more efficient for finding _one type_ by name, because it doesn't merge hashes.
-      def types(context = GraphQL::Query::NullContext.instance)
+      def types(context = null_context)
         if use_visibility_profile?
           types = Visibility::Profile.from_context(context, self)
           return types.all_types_h
@@ -366,7 +372,7 @@ module GraphQL
       # @param context [GraphQL::Query::Context] Used for filtering definitions at query-time
       # @param use_visibility_profile Private, for migration to {Schema::Visibility}
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
-      def get_type(type_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+      def get_type(type_name, context = null_context, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
           profile = Visibility::Profile.from_context(context, self)
           return profile.type(type_name)
@@ -617,7 +623,7 @@ module GraphQL
       # @param use_visibility_profile Private, for migration to {Schema::Visibility}
       # @return [Hash<String, Module>] All possible types, if no `type` is given.
       # @return [Array<Module>] Possible types for `type`, if it's given.
-      def possible_types(type = nil, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+      def possible_types(type = nil, context = null_context, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
           if type
             return Visibility::Profile.from_context(context, self).possible_types(type)
@@ -659,8 +665,8 @@ module GraphQL
           inherited_um = find_inherited_value(:union_memberships, EMPTY_HASH).fetch(type.graphql_name, EMPTY_ARRAY)
           own_um + inherited_um
         else
-          joined_um = own_union_memberships.dup
-          find_inherited_value(:union_memberhips, EMPTY_HASH).each do |k, v|
+          joined_um = own_union_memberships.transform_values(&:dup)
+          find_inherited_value(:union_memberships, EMPTY_HASH).each do |k, v|
             um = joined_um[k] ||= []
             um.concat(v)
           end
@@ -701,7 +707,7 @@ module GraphQL
         GraphQL::Schema::TypeExpression.build_type(context.query.types, ast_node)
       end
 
-      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+      def get_field(type_or_name, field_name, context = null_context, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
           profile = Visibility::Profile.from_context(context, self)
           parent_type = case type_or_name
@@ -738,7 +744,7 @@ module GraphQL
         end
       end
 
-      def get_fields(type, context = GraphQL::Query::NullContext.instance)
+      def get_fields(type, context = null_context)
         type.fields(context)
       end
 
@@ -751,6 +757,7 @@ module GraphQL
           # reset this cached value:
           @introspection_system = nil
           introspection_system
+          self.visibility&.introspection_system_configured(introspection_system)
           @introspection
         else
           @introspection || find_inherited_value(:introspection)
@@ -762,7 +769,6 @@ module GraphQL
         if !@introspection_system
           @introspection_system = Schema::IntrospectionSystem.new(self)
           @introspection_system.resolve_late_bindings
-          self.visibility&.introspection_system_configured(@introspection_system)
         end
         @introspection_system
       end
@@ -854,7 +860,7 @@ module GraphQL
       # @return [Array<GraphQL::StaticValidation::Error >]
       def validate(string_or_document, rules: nil, context: nil)
         doc = if string_or_document.is_a?(String)
-          GraphQL.parse(string_or_document)
+          GraphQL.parse(string_or_document, max_tokens: max_query_string_tokens)
         else
           string_or_document
         end
@@ -1144,17 +1150,14 @@ module GraphQL
       attr_accessor :using_backtrace
 
       # @api private
-      def handle_or_reraise(context, err)
+      def handle_or_reraise(context, err, object: context[:current_object], arguments: context[:current_arguments], field: context[:current_field])
         handler = Execution::Errors.find_handler_for(self, err.class)
         if handler
-          obj = context[:current_object]
-          args = context[:current_arguments]
-          args = args && args.respond_to?(:keyword_arguments) ? args.keyword_arguments : nil
-          field = context[:current_field]
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
+          arguments = arguments.respond_to?(:keyword_arguments) ? arguments.keyword_arguments : arguments
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
           end
-          handler[:handler].call(err, obj, args, context, field)
+          handler[:handler].call(err, object, arguments, context, field)
         else
           if (context[:backtrace] || using_backtrace) && !err.is_a?(GraphQL::ExecutionError)
             err = GraphQL::Backtrace::TracedError.new(err, context)
@@ -1228,6 +1231,7 @@ module GraphQL
           vis = self.visibility
           child_class.visibility = vis.dup_for(child_class)
         end
+        child_class.null_context = Query::NullContext.new(schema: child_class)
         super
       end
 
@@ -1329,13 +1333,14 @@ module GraphQL
       def type_error(type_error, context)
         case type_error
         when GraphQL::InvalidNullError
-          execution_error = GraphQL::ExecutionError.new(type_error.message, ast_node: type_error.ast_node)
-          execution_error.path = context[:current_path]
+          execution_error = GraphQL::ExecutionError.new(type_error.message, ast_nodes: type_error.ast_nodes)
+          execution_error.path = type_error.path || context[:current_path]
 
           context.errors << execution_error
-        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
+          execution_error
+        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::FloatEncodingError, GraphQL::IntegerEncodingError
           raise type_error
-        when GraphQL::IntegerDecodingError
+        when GraphQL::FloatDecodingError, GraphQL::IntegerDecodingError
           nil
         end
       end
@@ -1354,6 +1359,16 @@ module GraphQL
         lazy_methods.set(lazy_class, value_method)
       end
 
+      def resolves_lazies?
+        lazy_method_count = 0
+        lazy_methods.each do |k, v|
+          if !v.nil?
+            lazy_method_count += 1
+          end
+        end
+        lazy_method_count > 2
+      end
+
       def instrument(instrument_step, instrumenter, options = {})
         warn <<~WARN
         Schema.instrument is deprecated, use `trace_with` instead: https://graphql-ruby.org/queries/tracing.html"
@@ -1424,7 +1439,16 @@ module GraphQL
       end
 
       def tracers
-        find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
+        inherited = find_inherited_value(:tracers, EMPTY_ARRAY)
+        if inherited.length > 0
+          if own_tracers.length > 0
+            inherited + own_tracers
+          else
+            inherited
+          end
+        else
+          own_tracers
+        end
       end
 
       # Mix `trace_mod` into this schema's `Trace` class so that its methods will be called at runtime.
@@ -1534,7 +1558,8 @@ module GraphQL
       end
 
       def query_analyzers
-        find_inherited_value(:query_analyzers, EMPTY_ARRAY) + own_query_analyzers
+        inherited_qa = find_inherited_value(:query_analyzers, EMPTY_ARRAY)
+        inherited_qa.empty? ? own_query_analyzers : (inherited_qa + own_query_analyzers)
       end
 
       # @param new_analyzer [Class<GraphQL::Analysis::Analyzer>] An analyzer to run on multiplexes to this schema
@@ -1559,6 +1584,14 @@ module GraphQL
       # @see {Query#initialize} for arguments.
       # @return [GraphQL::Query::Result] query result, ready to be serialized as JSON
       def execute(query_str = nil, **kwargs)
+        if default_execution_next
+          execute_next(query_str, **kwargs)
+        else
+          execute_legacy(query_str, **kwargs)
+        end
+      end
+
+      def execute_legacy(query_str = nil, **kwargs)
         if query_str
           kwargs[:query] = query_str
         end
@@ -1600,7 +1633,23 @@ module GraphQL
       # @option kwargs [nil, Integer] :max_complexity (nil)
       # @return [Array<GraphQL::Query::Result>] One result for each query in the input
       def multiplex(queries, **kwargs)
-        GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
+        if @default_execution_next
+          multiplex_next(queries, **kwargs)
+        else
+          GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
+        end
+      end
+
+      def default_execution_next(new_value = NOT_CONFIGURED)
+        if !NOT_CONFIGURED.equal?(new_value)
+          @default_execution_next = new_value
+        elsif instance_variable_defined?(:@default_execution_next)
+          @default_execution_next
+        elsif superclass.respond_to?(:default_execution_next)
+          superclass.default_execution_next
+        else
+          false
+        end
       end
 
       def instrumenters
@@ -1708,7 +1757,7 @@ module GraphQL
       # If you need to support previous, non-spec behavior which allowed selecting union fields
       # but *not* selecting any fields on that union, set this to `true` to continue allowing that behavior.
       #
-      # If this is `true`, then {.legacy_invalid_empty_selections_on_union} will be called with {Query} objects
+      # If this is `true`, then {.legacy_invalid_empty_selections_on_union_with_type} will be called with {Query} objects
       # with that kind of selections. You must implement that method
       # @param new_value [Boolean]
       # @return [true, false, nil]
@@ -1724,6 +1773,22 @@ module GraphQL
         end
       end
 
+      # This method is called during validation when a previously-allowed, but non-spec
+      # query is encountered where a union field has no child selections on it.
+      #
+      # If `legacy_invalid_empty_selections_on_union_with_type` is overridden, this method will not be called.
+      #
+      # You should implement this method or `legacy_invalid_empty_selections_on_union_with_type`
+      # to log the violation so that you can contact clients and notify them about changing their queries.
+      # Then return a suitable value to tell GraphQL-Ruby how to continue.
+      # @param query [GraphQL::Query]
+      # @return [:return_validation_error] Let GraphQL-Ruby return the (new) normal validation error for this query
+      # @return [String] A validation error to return for this query
+      # @return [nil] Don't send the client an error, continue the legacy behavior (allow this query to execute)
+      def legacy_invalid_empty_selections_on_union(query)
+        raise "Implement `def self.legacy_invalid_empty_selections_on_union_with_type(query, type)` or `def self.legacy_invalid_empty_selections_on_union(query)` to handle this scenario"
+      end
+
       # This method is called during validation when a previously-allowed, but non-spec
       # query is encountered where a union field has no child selections on it.
       #
@@ -1731,11 +1796,12 @@ module GraphQL
       # and notify them about changing their queries. Then return a suitable value to
       # tell GraphQL-Ruby how to continue.
       # @param query [GraphQL::Query]
+      # @param type [Module] A GraphQL type definition
       # @return [:return_validation_error] Let GraphQL-Ruby return the (new) normal validation error for this query
       # @return [String] A validation error to return for this query
       # @return [nil] Don't send the client an error, continue the legacy behavior (allow this query to execute)
-      def legacy_invalid_empty_selections_on_union(query)
-        raise "Implement `def self.legacy_invalid_empty_selections_on_union(query)` to handle this scenario"
+      def legacy_invalid_empty_selections_on_union_with_type(query, type)
+        legacy_invalid_empty_selections_on_union(query)
       end
 
       # This setting controls how GraphQL-Ruby handles overlapping selections on scalar types when the types

data/lib/graphql/static_validation/base_visitor.rb

@@ -4,25 +4,26 @@ module GraphQL
     class BaseVisitor < GraphQL::Language::StaticVisitor
       def initialize(document, context)
         @path = []
-        @object_types = []
-        @directives = []
-        @field_definitions = []
-        @argument_definitions = []
-        @directive_definitions = []
+        @path_depth = 0
+        @current_object_type = nil
+        @parent_object_type = nil
+        @current_field_definition = nil
+        @current_argument_definition = nil
+        @parent_argument_definition = nil
+        @current_directive_definition = nil
         @context = context
         @types = context.query.types
         @schema = context.schema
+        @inline_fragment_paths = {}
+        @field_unwrapped_types = {}.compare_by_identity
         super(document)
       end
 
       attr_reader :context
 
-      # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
-      attr_reader :object_types
-
       # @return [Array<String>] The nesting of the current position in the AST
       def path
-        @path.dup
+        @path[0, @path_depth]
       end
 
       # Build a class to visit the AST and perform validation,
@@ -55,86 +56,125 @@ module GraphQL
       module ContextMethods
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
-          push_type(object_type)
-          @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          @current_object_type = object_type
+          @path[@path_depth] = "#{node.operation_type}#{node.name ? " #{node.name}" : ""}"
+          @path_depth += 1
           super
-          @object_types.pop
-          @path.pop
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
         def on_fragment_definition(node, parent)
-          on_fragment_with_type(node) do
-            @path.push("fragment #{node.name}")
-            super
+          object_type = if node.type
+            @types.type(node.type.name)
+          else
+            @current_object_type
           end
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          @current_object_type = object_type
+          @path[@path_depth] = "fragment #{node.name}"
+          @path_depth += 1
+          super
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
+        INLINE_FRAGMENT_NO_TYPE = "..."
+
         def on_inline_fragment(node, parent)
-          on_fragment_with_type(node) do
-            @path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
-            super
+          if node.type
+            object_type = @types.type(node.type.name)
+            @path[@path_depth] = @inline_fragment_paths[node.type.name] ||= -"... on #{node.type.to_query_string}"
+            @path_depth += 1
+          else
+            object_type = @current_object_type
+            @path[@path_depth] = INLINE_FRAGMENT_NO_TYPE
+            @path_depth += 1
           end
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          @current_object_type = object_type
+          super
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
         def on_field(node, parent)
-          parent_type = @object_types.last
+          parent_type = @current_object_type
           field_definition = @types.field(parent_type, node.name)
-          @field_definitions.push(field_definition)
-          if !field_definition.nil?
-            next_object_type = field_definition.type.unwrap
-            push_type(next_object_type)
+          prev_field_definition = @current_field_definition
+          @current_field_definition = field_definition
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          if field_definition
+            @current_object_type = @field_unwrapped_types[field_definition] ||= field_definition.type.unwrap
           else
-            push_type(nil)
+            @current_object_type = nil
           end
-          @path.push(node.alias || node.name)
+          @path[@path_depth] = node.alias || node.name
+          @path_depth += 1
           super
-          @field_definitions.pop
-          @object_types.pop
-          @path.pop
+          @current_field_definition = prev_field_definition
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
         def on_directive(node, parent)
           directive_defn = @context.schema_directives[node.name]
-          @directive_definitions.push(directive_defn)
+          prev_directive_definition = @current_directive_definition
+          @current_directive_definition = directive_defn
           super
-          @directive_definitions.pop
+          @current_directive_definition = prev_directive_definition
         end
 
         def on_argument(node, parent)
-          argument_defn = if (arg = @argument_definitions.last)
+          argument_defn = if (arg = @current_argument_definition)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
               @types.argument(arg_type, node.name)
             else
               nil
             end
-          elsif (directive_defn = @directive_definitions.last)
+          elsif (directive_defn = @current_directive_definition)
             @types.argument(directive_defn, node.name)
-          elsif (field_defn = @field_definitions.last)
+          elsif (field_defn = @current_field_definition)
             @types.argument(field_defn, node.name)
           else
             nil
           end
 
-          @argument_definitions.push(argument_defn)
-          @path.push(node.name)
+          prev_parent = @parent_argument_definition
+          @parent_argument_definition = @current_argument_definition
+          @current_argument_definition = argument_defn
+          @path[@path_depth] = node.name
+          @path_depth += 1
           super
-          @argument_definitions.pop
-          @path.pop
+          @current_argument_definition = @parent_argument_definition
+          @parent_argument_definition = prev_parent
+          @path_depth -= 1
         end
 
         def on_fragment_spread(node, parent)
-          @path.push("... #{node.name}")
+          @path[@path_depth] = "... #{node.name}"
+          @path_depth += 1
           super
-          @path.pop
+          @path_depth -= 1
         end
 
         def on_input_object(node, parent)
-          arg_defn = @argument_definitions.last
+          arg_defn = @current_argument_definition
           if arg_defn && arg_defn.type.list?
-            @path.push(parent.children.index(node))
+            @path[@path_depth] = parent.children.index(node)
+            @path_depth += 1
             super
-            @path.pop
+            @path_depth -= 1
           else
             super
           end
@@ -142,48 +182,32 @@ module GraphQL
 
         # @return [GraphQL::BaseType] The current object type
         def type_definition
-          @object_types.last
+          @current_object_type
         end
 
         # @return [GraphQL::BaseType] The type which the current type came from
         def parent_type_definition
-          @object_types[-2]
+          @parent_object_type
         end
 
         # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
         def field_definition
-          @field_definitions.last
+          @current_field_definition
         end
 
         # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
         def directive_definition
-          @directive_definitions.last
+          @current_directive_definition
         end
 
         # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
         def argument_definition
-          # Don't get the _last_ one because that's the current one.
-          # Get the second-to-last one, which is the parent of the current one.
-          @argument_definitions[-2]
+          # Return the parent argument definition (not the current one).
+          @parent_argument_definition
         end
 
         private
 
-        def on_fragment_with_type(node)
-          object_type = if node.type
-            @types.type(node.type.name)
-          else
-            @object_types.last
-          end
-          push_type(object_type)
-          yield(node)
-          @object_types.pop
-          @path.pop
-        end
-
-        def push_type(t)
-          @object_types.push(t)
-        end
       end
 
       private
@@ -192,7 +216,7 @@ module GraphQL
         if @context.too_many_errors?
           throw :too_many_validation_errors
         end
-        error.path ||= (path || @path.dup)
+        error.path ||= (path || @path[0, @path_depth])
         context.errors << error
       end