graphql 2.0.27 → 2.2.6

data/lib/graphql/schema.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "logger"
 require "graphql/schema/addition"
 require "graphql/schema/always_visible"
 require "graphql/schema/base_64_encoder"
@@ -37,10 +38,12 @@ require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
+require "graphql/schema/directive/specified_by"
 require "graphql/schema/type_membership"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
+require "graphql/schema/has_single_input_argument"
 require "graphql/schema/relay_classic_mutation"
 require "graphql/schema/subscription"
 
@@ -144,6 +147,19 @@ module GraphQL
         @subscriptions = new_implementation
       end
 
+      # @param new_mode [Symbol] If configured, this will be used when `context: { trace_mode: ... }` isn't set.
+      def default_trace_mode(new_mode = nil)
+        if new_mode
+          @default_trace_mode = new_mode
+        elsif defined?(@default_trace_mode)
+          @default_trace_mode
+        elsif superclass.respond_to?(:default_trace_mode)
+          superclass.default_trace_mode
+        else
+          :default
+        end
+      end
+
       def trace_class(new_class = nil)
         if new_class
           trace_mode(:default, new_class)
@@ -155,42 +171,66 @@ module GraphQL
       end
 
       # @return [Class] Return the trace class to use for this mode, looking one up on the superclass if this Schema doesn't have one defined.
-      def trace_class_for(mode)
-        @trace_modes ||= {}
-        @trace_modes[mode] ||= begin
-          case mode
-          when :default
-            superclass_base_class = if superclass.respond_to?(:trace_class_for)
-              superclass.trace_class_for(mode)
-            else
-              GraphQL::Tracing::Trace
-            end
-            Class.new(superclass_base_class)
-          when :default_backtrace
-            schema_base_class = trace_class_for(:default)
-            Class.new(schema_base_class) do
-              include(GraphQL::Backtrace::Trace)
-            end
-          else
-            mods = trace_modules_for(mode)
-            Class.new(trace_class_for(:default)) do
-              mods.any? && include(*mods)
-            end
-          end
-        end
+      def trace_class_for(mode, build: true)
+        own_trace_modes[mode] ||
+          (superclass.respond_to?(:trace_class_for) ? superclass.trace_class_for(mode, build: build) : (build ? (own_trace_modes[mode] = build_trace_mode(mode)) : nil))
       end
 
       # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
-      # `:default` is used when no `trace_mode: ...` is requested.
+      # {default_trace_mode} is used when no `trace_mode: ...` is requested.
+      #
+      # When a `trace_class` is added this way, it will _not_ receive other modules added with `trace_with(...)`
+      # unless `trace_mode` is explicitly given. (This class will not recieve any default trace modules.)
+      #
+      # Subclasses of the schema will use `trace_class` as a base class for this mode and those
+      # subclass also will _not_ receive default tracing modules.
+      #
       # @param mode_name [Symbol]
       # @param trace_class [Class] subclass of GraphQL::Tracing::Trace
       # @return void
       def trace_mode(mode_name, trace_class)
-        @trace_modes ||= {}
-        @trace_modes[mode_name] = trace_class
+        own_trace_modes[mode_name] = trace_class
         nil
       end
 
+      def own_trace_modes
+        @own_trace_modes ||= {}
+      end
+
+      module DefaultTraceClass
+      end
+
+      private_constant :DefaultTraceClass
+
+      def build_trace_mode(mode)
+        case mode
+        when :default
+          # Use the superclass's default mode if it has one, or else start an inheritance chain at the built-in base class.
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode)) || GraphQL::Tracing::Trace
+          Class.new(base_class) do
+            include DefaultTraceClass
+          end
+        when :default_backtrace
+          schema_base_class = trace_class_for(:default)
+          Class.new(schema_base_class) do
+            include(GraphQL::Backtrace::Trace)
+          end
+        else
+          # First, see if the superclass has a custom-defined class for this.
+          # Then, if it doesn't, use this class's default trace
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode, build: false)) || trace_class_for(:default)
+          # Prepare the default trace class if it hasn't been initialized yet
+          base_class ||= (own_trace_modes[:default] = build_trace_mode(:default))
+          mods = trace_modules_for(mode)
+          if base_class < DefaultTraceClass
+            mods = trace_modules_for(:default) + mods
+          end
+          Class.new(base_class) do
+            mods.any? && include(*mods)
+          end
+        end
+      end
+
       def own_trace_modules
         @own_trace_modules ||= Hash.new { |h, k| h[k] = [] }
       end
@@ -222,7 +262,7 @@ module GraphQL
       # @param include_specified_by_url [Boolean] If true, scalar types' `specifiedByUrl:` will be included in the response
       # @param include_is_one_of [Boolean] If true, `isOneOf: true|false` will be included with input objects
       # @return [Hash] GraphQL result
-      def as_json(only: nil, except: nil, context: {}, include_deprecated_args: true, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
+      def as_json(context: {}, include_deprecated_args: true, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
         introspection_query = Introspection.query(
           include_deprecated_args: include_deprecated_args,
           include_schema_description: include_schema_description,
@@ -231,16 +271,14 @@ module GraphQL
           include_specified_by_url: include_specified_by_url,
         )
 
-        execute(introspection_query, only: only, except: except, context: context).to_h
+        execute(introspection_query, context: context).to_h
       end
 
       # Return the GraphQL IDL for the schema
       # @param context [Hash]
-      # @param only [<#call(member, ctx)>]
-      # @param except [<#call(member, ctx)>]
       # @return [String]
-      def to_definition(only: nil, except: nil, context: {})
-        GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
+      def to_definition(context: {})
+        GraphQL::Schema::Printer.print_schema(self, context: context)
       end
 
       # Return the GraphQL::Language::Document IDL AST for the schema
@@ -268,20 +306,6 @@ module GraphQL
         @find_cache[path] ||= @finder.find(path)
       end
 
-      def default_filter
-        GraphQL::Filter.new(except: default_mask)
-      end
-
-      def default_mask(new_mask = nil)
-        if new_mask
-          line = caller(2, 10).find { |l| !l.include?("lib/graphql") }
-          GraphQL::Deprecation.warn("GraphQL::Filter and Schema.mask are deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).\n  #{line}")
-          @own_default_mask = new_mask
-        else
-          @own_default_mask || find_inherited_value(:default_mask, Schema::NullMask)
-        end
-      end
-
       def static_validator
         GraphQL::StaticValidation::Validator.new(schema: self)
       end
@@ -302,7 +326,7 @@ module GraphQL
       # 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)
+      def types(context = GraphQL::Query::NullContext.instance)
         all_types = non_introspection_types.merge(introspection_system.types)
         visible_types = {}
         all_types.each do |k, v|
@@ -329,7 +353,7 @@ module GraphQL
 
       # @param type_name [String]
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
-      def get_type(type_name, context = GraphQL::Query::NullContext)
+      def get_type(type_name, context = GraphQL::Query::NullContext.instance)
         local_entry = own_types[type_name]
         type_defn = case local_entry
         when nil
@@ -360,6 +384,11 @@ module GraphQL
           (superclass.respond_to?(:get_type) ? superclass.get_type(type_name, context) : nil)
       end
 
+      # @return [Boolean] Does this schema have _any_ definition for a type named `type_name`, regardless of visibility?
+      def has_defined_type?(type_name)
+        own_types.key?(type_name) || introspection_system.types.key?(type_name) || (superclass.respond_to?(:has_defined_type?) ? superclass.has_defined_type?(type_name) : false)
+      end
+
       # @api private
       attr_writer :connections
 
@@ -460,7 +489,7 @@ module GraphQL
       # @param type [Module] The type definition whose possible types you want to see
       # @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)
+      def possible_types(type = nil, context = GraphQL::Query::NullContext.instance)
         if type
           # TODO duck-typing `.possible_types` would probably be nicer here
           if type.kind.union?
@@ -513,18 +542,17 @@ module GraphQL
       attr_writer :dataloader_class
 
       def references_to(to_type = nil, from: nil)
-        @own_references_to ||= Hash.new { |h, k| h[k] = [] }
+        @own_references_to ||= {}
         if to_type
           if !to_type.is_a?(String)
             to_type = to_type.graphql_name
           end
 
           if from
-            @own_references_to[to_type] << from
+            refs = @own_references_to[to_type] ||= []
+            refs << from
           else
-            own_refs = @own_references_to[to_type]
-            inherited_refs = find_inherited_value(:references_to, EMPTY_HASH)[to_type] || EMPTY_ARRAY
-            own_refs + inherited_refs
+            get_references_to(to_type) || EMPTY_ARRAY
           end
         else
           # `@own_references_to` can be quite large for big schemas,
@@ -544,7 +572,7 @@ module GraphQL
         GraphQL::Schema::TypeExpression.build_type(type_owner, ast_node)
       end
 
-      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext)
+      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance)
         parent_type = case type_or_name
         when LateBoundType
           get_type(type_or_name.name, context)
@@ -567,7 +595,7 @@ module GraphQL
         end
       end
 
-      def get_fields(type, context = GraphQL::Query::NullContext)
+      def get_fields(type, context = GraphQL::Query::NullContext.instance)
         type.fields(context)
       end
 
@@ -657,7 +685,7 @@ module GraphQL
         else
           string_or_document
         end
-        query = GraphQL::Query.new(self, document: doc, context: context)
+        query = query_class.new(self, document: doc, context: context)
         validator_opts = { schema: self }
         rules && (validator_opts[:rules] = rules)
         validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
@@ -665,6 +693,14 @@ module GraphQL
         res[:errors]
       end
 
+      def query_class(new_query_class = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_query_class)
+          @query_class || (superclass.respond_to?(:query_class) ? superclass.query_class : GraphQL::Query)
+        else
+          @query_class = new_query_class
+        end
+      end
+
       attr_writer :validate_max_errors
 
       def validate_max_errors(new_validate_max_errors = nil)
@@ -717,9 +753,10 @@ module GraphQL
 
       attr_writer :max_depth
 
-      def max_depth(new_max_depth = nil)
+      def max_depth(new_max_depth = nil, count_introspection_fields: true)
         if new_max_depth
           @max_depth = new_max_depth
+          @count_introspection_fields = count_introspection_fields
         elsif defined?(@max_depth)
           @max_depth
         else
@@ -727,6 +764,14 @@ module GraphQL
         end
       end
 
+      def count_introspection_fields
+        if defined?(@count_introspection_fields)
+          @count_introspection_fields
+        else
+          find_inherited_value(:count_introspection_fields, true)
+        end
+      end
+
       def disable_introspection_entry_points
         @disable_introspection_entry_points = true
         # TODO: this clears the cache made in `def types`. But this is not a great solution.
@@ -769,6 +814,26 @@ module GraphQL
         end
       end
 
+      # @param new_extra_types [Module] Type definitions to include in printing and introspection, even though they aren't referenced in the schema
+      # @return [Array<Module>] Type definitions added to this schema
+      def extra_types(*new_extra_types)
+        if new_extra_types.any?
+          new_extra_types = new_extra_types.flatten
+          @own_extra_types ||= []
+          @own_extra_types.concat(new_extra_types)
+        end
+        inherited_et = find_inherited_value(:extra_types, nil)
+        if inherited_et
+          if @own_extra_types
+            inherited_et + @own_extra_types
+          else
+            inherited_et
+          end
+        else
+          @own_extra_types || EMPTY_ARRAY
+        end
+      end
+
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
           new_orphan_types = new_orphan_types.flatten
@@ -776,7 +841,16 @@ module GraphQL
           own_orphan_types.concat(new_orphan_types.flatten)
         end
 
-        find_inherited_value(:orphan_types, EMPTY_ARRAY) + own_orphan_types
+        inherited_ot = find_inherited_value(:orphan_types, nil)
+        if inherited_ot
+          if own_orphan_types.any?
+            inherited_ot + own_orphan_types
+          else
+            inherited_ot
+          end
+        else
+          own_orphan_types
+        end
       end
 
       def default_execution_strategy
@@ -795,6 +869,26 @@ module GraphQL
         end
       end
 
+      def default_logger(new_default_logger = NOT_CONFIGURED)
+        if NOT_CONFIGURED.equal?(new_default_logger)
+          if defined?(@default_logger)
+            @default_logger
+          elsif superclass.respond_to?(:default_logger)
+            superclass.default_logger
+          elsif defined?(Rails) && Rails.respond_to?(:logger) && (rails_logger = Rails.logger)
+            rails_logger
+          else
+            def_logger = Logger.new($stdout)
+            def_logger.info! # It doesn't output debug info by default
+            def_logger
+          end
+        elsif new_default_logger == nil
+          @default_logger = Logger.new(IO::NULL)
+        else
+          @default_logger = new_default_logger
+        end
+      end
+
       def context_class(new_context_class = nil)
         if new_context_class
           @context_class = new_context_class
@@ -870,17 +964,19 @@ module GraphQL
       end
 
       def resolve_type(type, obj, ctx)
-        if type.kind.object?
-          type
-        else
-          raise GraphQL::RequiredImplementationMissingError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
-        end
+        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types, Interface types, or `loads:` (tried to resolve: #{type.name})"
       end
       # rubocop:enable Lint/DuplicateMethods
 
       def inherited(child_class)
         if self == GraphQL::Schema
           child_class.directives(default_directives.values)
+          child_class.extend(SubclassGetReferencesTo)
+        end
+        # Make sure the child class has these built out, so that
+        # subclasses can be modified by later calls to `trace_with`
+        own_trace_modes.each do |name, _class|
+          child_class.own_trace_modes[name] = child_class.build_trace_mode(name)
         end
         child_class.singleton_class.prepend(ResolveTypeWithType)
         super
@@ -968,6 +1064,12 @@ module GraphQL
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        warn <<~WARN
+        Schema.instrument is deprecated, use `trace_with` instead: https://graphql-ruby.org/queries/tracing.html"
+          (From `#{self}.instrument(#{instrument_step}, #{instrumenter})` at #{caller(1, 1).first})
+
+        WARN
+        trace_with(Tracing::LegacyHooksTrace)
         own_instrumenters[instrument_step] << instrumenter
       end
 
@@ -978,7 +1080,12 @@ module GraphQL
           new_directives.flatten.each { |d| directive(d) }
         end
 
-        find_inherited_value(:directives, default_directives).merge(own_directives)
+        inherited_dirs = find_inherited_value(:directives, default_directives)
+        if own_directives.any?
+          inherited_dirs.merge(own_directives)
+        else
+          inherited_dirs
+        end
       end
 
       # Attach a single directive to this schema
@@ -994,11 +1101,13 @@ module GraphQL
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
           "oneOf" => GraphQL::Schema::Directive::OneOf,
+          "specifiedBy" => GraphQL::Schema::Directive::SpecifiedBy,
         }.freeze
       end
 
       def tracer(new_tracer)
-        if !(trace_class_for(:default) < GraphQL::Tracing::CallLegacyTracers)
+        default_trace = trace_class_for(:default)
+        if default_trace.nil? || !(default_trace < GraphQL::Tracing::CallLegacyTracers)
           trace_with(GraphQL::Tracing::CallLegacyTracers)
         end
 
@@ -1020,10 +1129,20 @@ module GraphQL
         if mode.is_a?(Array)
           mode.each { |m| trace_with(trace_mod, mode: m, **options) }
         else
-          tc = trace_class_for(mode)
+          tc = own_trace_modes[mode] ||= build_trace_mode(mode)
           tc.include(trace_mod)
-          if mode != :default
-            own_trace_modules[mode] << trace_mod
+          own_trace_modules[mode] << trace_mod
+
+          if mode == :default
+            # This module is being added as a default tracer. If any other mode classes
+            # have already been created, but get their default behavior from a superclass,
+            # Then mix this into this schema's subclass.
+            # (But don't mix it into mode classes that aren't default-based.)
+            own_trace_modes.each do |other_mode_name, other_mode_class|
+              if other_mode_class < DefaultTraceClass && !(other_mode_class < trace_mod)
+                other_mode_class.include(trace_mod)
+              end
+            end
           end
           t_opts = trace_options_for(mode)
           t_opts.merge!(options)
@@ -1046,6 +1165,8 @@ module GraphQL
 
       # Create a trace instance which will include the trace modules specified for the optional mode.
       #
+      # If no `mode:` is given, then {default_trace_mode} will be used.
+      #
       # @param mode [Symbol] Trace modules for this trade mode will be included
       # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
       # @return [Tracing::Trace]
@@ -1056,14 +1177,19 @@ module GraphQL
         trace_mode = if mode
           mode
         elsif target && target.context[:backtrace]
-          :default_backtrace
+          if default_trace_mode != :default
+            raise ArgumentError, "Can't use `context[:backtrace]` with a custom default trace mode (`#{dm.inspect}`)"
+          else
+            own_trace_modes[:default_backtrace] ||= build_trace_mode(:default_backtrace)
+            :default_backtrace
+          end
         else
-          :default
+          default_trace_mode
         end
 
         base_trace_options = trace_options_for(trace_mode)
         trace_options = base_trace_options.merge(options)
-        trace_class_for_mode = trace_class_for(trace_mode)
+        trace_class_for_mode = trace_class_for(trace_mode) || raise(ArgumentError, "#{self} has no trace class for mode: #{trace_mode.inspect}")
         trace_class_for_mode.new(**trace_options)
       end
 
@@ -1327,6 +1453,27 @@ module GraphQL
       def own_multiplex_analyzers
         @own_multiplex_analyzers ||= []
       end
+
+      # This is overridden in subclasses to check the inheritance chain
+      def get_references_to(type_name)
+        @own_references_to[type_name]
+      end
+    end
+
+    module SubclassGetReferencesTo
+      def get_references_to(type_name)
+        own_refs = @own_references_to[type_name]
+        inherited_refs = superclass.references_to(type_name)
+        if inherited_refs&.any?
+          if own_refs&.any?
+            own_refs + inherited_refs
+          else
+            inherited_refs
+          end
+        else
+          own_refs
+        end
+      end
     end
 
     # Install these here so that subclasses will also install it.

data/lib/graphql/static_validation/all_rules.rb

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     # Default rules for {GraphQL::StaticValidation::Validator}
     #
-    # Order is important here. Some validators return {GraphQL::Language::Visitor::SKIP}
+    # Order is important here. Some validators skip later hooks.
     # which stops the visit on that node. That way it doesn't try to find fields on types that
     # don't exist, etc.
     ALL_RULES = [

data/lib/graphql/static_validation/base_visitor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class BaseVisitor < GraphQL::Language::Visitor
+    class BaseVisitor < GraphQL::Language::StaticVisitor
       def initialize(document, context)
         @path = []
         @object_types = []

data/lib/graphql/static_validation/literal_validator.rb

@@ -111,7 +111,7 @@ module GraphQL
         # that required fields are missing
         required_field_names = @warden.arguments(type)
           .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
-          .map(&:name)
+          .map!(&:name)
 
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -340,7 +340,7 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            definition = context.query.get_field(owner_type, node.name)
+            definition = context.warden.get_field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -21,7 +21,7 @@ module GraphQL
         present_argument_names = ast_node.arguments.map(&:name)
         required_argument_names = context.warden.arguments(defn)
           .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
-          .map(&:name)
+          .map!(&:name)
 
         missing_names = required_argument_names - present_argument_names
         if missing_names.any?

data/lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb

@@ -36,7 +36,7 @@ module GraphQL
 
         required_fields = context.warden.arguments(parent_type)
           .select{|arg| arg.type.kind.non_null?}
-          .map(&:graphql_name)
+          .map!(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)
         missing_fields = required_fields - present_fields

data/lib/graphql/static_validation/validation_context.rb

@@ -8,20 +8,20 @@ module GraphQL
     # It provides access to the schema & fragments which validators may read from.
     #
     # It holds a list of errors which each validator may add to.
-    #
-    # It also provides limited access to the {TypeStack} instance,
-    # which tracks state as you climb in and out of different fields.
     class ValidationContext
       extend Forwardable
 
       attr_reader :query, :errors, :visitor,
         :on_dependency_resolve_handlers,
-        :max_errors
+        :max_errors, :warden, :schema
+
 
-      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
+      def_delegators :@query, :document, :fragments, :operations
 
       def initialize(query, visitor_class, max_errors)
         @query = query
+        @warden = query.warden
+        @schema = query.schema
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
         @max_errors = max_errors || Float::INFINITY

data/lib/graphql/static_validation/validator.rb

@@ -28,6 +28,7 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
         query.current_trace.validate(validate: validate, query: query) do
+          begin_t = Time.now
           errors = if validate == false
             []
           else
@@ -52,11 +53,13 @@ module GraphQL
           end
 
           {
+            remaining_timeout: timeout ? (timeout - (Time.now - begin_t)) : nil,
             errors: errors,
           }
         end
       rescue GraphQL::ExecutionError => e
         {
+          remaining_timeout: nil,
           errors: [e],
         }
       end

data/lib/graphql/static_validation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require "graphql/static_validation/error"
 require "graphql/static_validation/definition_dependencies"
-require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
 require "graphql/static_validation/validation_timeout_error"

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -35,7 +35,7 @@ module GraphQL
     #       }
     #
     #       result = MySchema.execute(
-    #         query: query,
+    #         query,
     #         context: context,
     #         variables: variables,
     #         operation_name: operation_name
@@ -124,7 +124,8 @@ module GraphQL
       # This subscription was re-evaluated.
       # Send it to the specific stream where this client was waiting.
       def deliver(subscription_id, result)
-        payload = { result: result.to_h, more: true }
+        has_more = !result.context.namespace(:subscriptions)[:final_update]
+        payload = { result: result.to_h, more: has_more }
         @action_cable.server.broadcast(stream_subscription_name(subscription_id), payload)
       end