graphql 1.10.14 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1d76918804bdeeba0c80bbcfcdde70d04132110aee8e4520dcba8480da390fc
-  data.tar.gz: c0e1954ae3f6d18bf03fc33807b94d482b83b4e4a6f8a392452e2f6e8297f241
+  metadata.gz: 5fa7fb8135053075bd0575c9248d4e98521d0591fa26fbddc910125b1b8ea5d6
+  data.tar.gz: 982e434c521e7989f65364b7dd3e1540857a5110fc589e55b94196d802b6c6b0
 SHA512:
-  metadata.gz: 3e945033f8657c252fcd99a18d4be5c9d267535753e88a94f3b589c968ca186e90f3368768ff2f3f7c7e1eff7a210bf57694bde763255ee0a91f1e46534b0b4d
-  data.tar.gz: de56338439eeb22b8484033c5acfb4ac027edee60ac30218c8a7516c5bc6d4bfa07b8be54ebd42a63fca5decdfbbcf85e4b96832bb8d7fcd304dc2fb98bc7625
+  metadata.gz: 10d507db573e239973114d7ef6cdff1d3532165f408dc0e93e5f63e0247ec552dbf3c93d53a85df1f8d00325126e1c101d9aae8e38879771d1aaa4f7238b98da
+  data.tar.gz: 127f3b84714f80ca41196d2ebc415f694164283d52e3cbacea25a6ec164deac88e70f4447a6af340a3ce8599ebf50489d490522fa509e112bf44d1d33eaf0fba

data/lib/graphql/directive.rb

@@ -99,10 +99,6 @@ module GraphQL
     def type_class
       metadata[:type_class]
     end
-
-    def get_argument(argument_name)
-      arguments[argument_name]
-    end
   end
 end
 

data/lib/graphql/execution/interpreter.rb

@@ -26,7 +26,7 @@ module GraphQL
         schema_class.query_execution_strategy(GraphQL::Execution::Interpreter)
         schema_class.mutation_execution_strategy(GraphQL::Execution::Interpreter)
         schema_class.subscription_execution_strategy(GraphQL::Execution::Interpreter)
-
+        schema_class.add_subscription_extension_if_necessary
         GraphQL::Schema::Object.include(HandlesRawValue)
       end
 

data/lib/graphql/execution/interpreter/runtime.rb

@@ -460,9 +460,8 @@ module GraphQL
         end
 
         def arguments(graphql_object, arg_owner, ast_node)
-          # Don't cache arguments if field extras or extensions are requested since they can mutate the argument data structure
-          if arg_owner.arguments_statically_coercible? &&
-              (!arg_owner.is_a?(GraphQL::Schema::Field) || (arg_owner.extras.empty? && arg_owner.extensions.empty?))
+          # Don't cache arguments if field extras are requested since extras mutate the argument data structure
+          if arg_owner.arguments_statically_coercible? && (!arg_owner.is_a?(GraphQL::Schema::Field) || arg_owner.extras.empty?)
             query.arguments_for(ast_node, arg_owner)
           else
             # The arguments must be prepared in the context of the given object

data/lib/graphql/execution/multiplex.rb

@@ -34,8 +34,7 @@ module GraphQL
         @schema = schema
         @queries = queries
         @context = context
-        # TODO remove support for global tracers
-        @tracers = schema.tracers + GraphQL::Tracing.tracers + (context[:tracers] || [])
+        @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
           @tracers << GraphQL::Backtrace::Tracer

data/lib/graphql/field.rb

@@ -207,10 +207,6 @@ module GraphQL
       metadata[:type_class]
     end
 
-    def get_argument(argument_name)
-      arguments[argument_name]
-    end
-
     private
 
     def build_default_resolver

data/lib/graphql/input_object_type.rb

@@ -58,10 +58,6 @@ module GraphQL
       result
     end
 
-    def get_argument(argument_name)
-      arguments[argument_name]
-    end
-
     private
 
     def coerce_non_null_input(value, ctx)

data/lib/graphql/introspection/schema_type.rb

@@ -9,9 +9,9 @@ module GraphQL
                   "query, mutation, and subscription operations."
 
       field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
-      field :queryType, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
-      field :mutationType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
-      field :subscriptionType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
+      field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
+      field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
+      field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
 
       def types

data/lib/graphql/pagination/connection.rb

@@ -26,6 +26,9 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_accessor :context
 
+      # @return [Object] the object this collection belongs to
+      attr_accessor :parent
+
       # Raw access to client-provided values. (`max_page_size` not applied to first or last.)
       attr_accessor :before_value, :after_value, :first_value, :last_value
 
@@ -49,13 +52,15 @@ module GraphQL
 
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
       # @param context [Query::Context]
+      # @param parent [Object] The object this collection belongs to
       # @param first [Integer, nil] The limit parameter from the client, if it provided one
       # @param after [String, nil] A cursor for pagination, if the client provided one
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil)
+      def initialize(items, parent: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil)
         @items = items
+        @parent = parent
         @context = context
         @first_value = first
         @after_value = after
@@ -185,17 +190,19 @@ module GraphQL
       # A wrapper around paginated items. It includes a {cursor} for pagination
       # and could be extended with custom relationship-level data.
       class Edge
-        def initialize(item, connection)
+        attr_reader :node
+
+        def initialize(node, connection)
           @connection = connection
-          @item = item
+          @node = node
         end
 
-        def node
-          @item
+        def parent
+          @connection.parent
         end
 
         def cursor
-          @connection.cursor_for(@item)
+          @cursor ||= @connection.cursor_for(@node)
         end
       end
     end

data/lib/graphql/pagination/connections.rb

@@ -65,21 +65,22 @@ module GraphQL
 
       # Used by the runtime to wrap values in connection wrappers.
       # @api Private
-      def wrap(field, object, arguments, context, wrappers: all_wrappers)
+      def wrap(field, parent, items, arguments, context, wrappers: all_wrappers)
         impl = nil
 
-        object.class.ancestors.each { |cls|
+        items.class.ancestors.each { |cls|
           impl = wrappers[cls]
           break if impl
         }
 
         if impl.nil?
-          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{object.class} during #{field.path} (#{object.inspect})"
+          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
         end
 
         impl.new(
-          object,
+          items,
           context: context,
+          parent: parent,
           max_page_size: field.max_page_size || context.schema.default_max_page_size,
           first: arguments[:first],
           after: arguments[:after],

data/lib/graphql/query.rb

@@ -96,8 +96,7 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
-      # TODO: remove support for global tracers
-      @tracers = schema.tracers + GraphQL::Tracing.tracers + (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
         @tracers << GraphQL::Backtrace::Tracer

data/lib/graphql/schema.rb

@@ -1075,6 +1075,7 @@ module GraphQL
             raise GraphQL::Error, "Second definition of `subscription(...)` (#{new_subscription_object.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
           else
             @subscription_object = new_subscription_object
+            add_subscription_extension_if_necessary
             add_type_and_traverse(new_subscription_object, root: true)
             nil
           end
@@ -1648,6 +1649,20 @@ module GraphQL
         end
       end
 
+      # @api private
+      def add_subscription_extension_if_necessary
+        if interpreter? && !defined?(@subscription_extension_added) && subscription && self.subscriptions
+          @subscription_extension_added = true
+          if subscription.singleton_class.ancestors.include?(Subscriptions::SubscriptionRoot)
+            warn("`extend Subscriptions::SubscriptionRoot` is no longer required; you may remove it from #{self}'s `subscription` root type (#{subscription}).")
+          else
+            subscription.fields.each do |name, field|
+              field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
+            end
+          end
+        end
+      end
+
       private
 
       def lazy_methods

data/lib/graphql/schema/build_from_definition.rb

@@ -43,9 +43,7 @@ module GraphQL
             when GraphQL::Language::Nodes::EnumTypeDefinition
               types[definition.name] = build_enum_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ObjectTypeDefinition
-              is_subscription_root = (definition.name == "Subscription" && (schema_definition.nil? || schema_definition.subscription.nil?)) || (schema_definition && (definition.name == schema_definition.subscription))
-              should_extend_subscription_root = is_subscription_root && interpreter
-              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve, extend_subscription_root: should_extend_subscription_root)
+              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve)
             when GraphQL::Language::Nodes::InterfaceTypeDefinition
               types[definition.name] = build_interface_type(definition, type_resolver)
             when GraphQL::Language::Nodes::UnionTypeDefinition
@@ -204,7 +202,7 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver, default_resolve:, extend_subscription_root:)
+        def build_object_type(object_type_definition, type_resolver, default_resolve:)
           builder = self
           type_def = nil
           typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
@@ -214,10 +212,6 @@ module GraphQL
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
-            if extend_subscription_root
-              # This has to come before `field ...` configurations since it modifies them
-              extend Subscriptions::SubscriptionRoot
-            end
 
             object_type_definition.interfaces.each do |interface_name|
               interface_defn = type_resolver.call(interface_name)
@@ -303,7 +297,7 @@ module GraphQL
 
           field_definitions.map do |field_definition|
             type_name = resolve_type_name(field_definition.type)
-
+            resolve_method_name = "resolve_field_#{field_definition.name}"
             owner.field(
               field_definition.name,
               description: field_definition.description,
@@ -315,14 +309,15 @@ module GraphQL
               ast_node: field_definition,
               method_conflict_warning: false,
               camelize: false,
+              resolver_method: resolve_method_name,
             ) do
               builder.build_arguments(self, field_definition.arguments, type_resolver)
 
               # Don't do this for interfaces
               if default_resolve
-                # TODO fragile hack. formalize this API?
-                define_singleton_method :resolve_field_method do |obj, args, ctx|
-                  default_resolve.call(self, obj.object, args, ctx)
+                owner.send(:define_method, resolve_method_name) do |**args|
+                  field_instance = self.class.get_field(field_definition.name)
+                  default_resolve.call(field_instance, object, args, context)
                 end
               end
             end

data/lib/graphql/schema/field.rb

@@ -191,9 +191,10 @@ module GraphQL
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
       # @param extensions [Array<Class, Hash<Class => Object>>] Named extensions to apply to this field (see also {#extension})
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
+      # @param broadcastable [Boolean] Whether or not this field can be distributed in subscription broadcasts
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], 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, arguments: EMPTY_HASH, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], 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: nil, arguments: EMPTY_HASH, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -237,8 +238,8 @@ module GraphQL
         end
 
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
-        method_name = method || hash_key || @underscored_name
-        resolver_method ||= @underscored_name.to_sym
+        method_name = method || hash_key || name_s
+        resolver_method ||= name_s.to_sym
 
         @method_str = method_name.to_s
         @method_sym = method_name.to_sym
@@ -251,6 +252,7 @@ module GraphQL
         @max_page_size = max_page_size == :not_given ? nil : max_page_size
         @introspection = introspection
         @extras = extras
+        @broadcastable = broadcastable
         @resolver_class = resolver_class
         @scope = scope
         @trace = trace
@@ -295,6 +297,13 @@ module GraphQL
         end
       end
 
+      # If true, subscription updates with this field can be shared between viewers
+      # @return [Boolean, nil]
+      # @see GraphQL::Subscriptions::BroadcastAnalyzer
+      def broadcastable?
+        @broadcastable
+      end
+
       # @param text [String]
       # @return [String]
       def description(text = nil)
@@ -534,7 +543,7 @@ module GraphQL
                   @resolve_proc.call(extended_obj, args, ctx)
                 end
               else
-                public_send_field(after_obj, ruby_args, ctx)
+                public_send_field(after_obj, ruby_args, query_ctx)
               end
             else
               err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
@@ -558,30 +567,7 @@ module GraphQL
           application_object = object.object
           ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
             if is_authorized
-              # Apply field extensions
-              with_extensions(object, args, ctx) do |extended_obj, extended_args|
-                field_receiver = if @resolver_class
-                  resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
-                    extended_obj.object
-                  else
-                    extended_obj
-                  end
-                  @resolver_class.new(object: resolver_obj, context: ctx, field: self)
-                else
-                  extended_obj
-                end
-
-                if field_receiver.respond_to?(@resolver_method)
-                  # Call the method with kwargs, if there are any
-                  if extended_args.any?
-                    field_receiver.public_send(@resolver_method, **extended_args)
-                  else
-                    field_receiver.public_send(@resolver_method)
-                  end
-                else
-                  resolve_field_method(field_receiver, extended_args, ctx)
-                end
-              end
+              public_send_field(object, args, ctx)
             else
               err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
               ctx.schema.unauthorized_field(err)
@@ -597,43 +583,6 @@ module GraphQL
         err
       end
 
-      # Find a way to resolve this field, checking:
-      #
-      # - Hash keys, if the wrapped object is a hash;
-      # - A method on the wrapped object;
-      # - Or, raise not implemented.
-      #
-      # This can be overridden by defining a method on the object type.
-      # @param obj [GraphQL::Schema::Object]
-      # @param ruby_kwargs [Hash<Symbol => Object>]
-      # @param ctx [GraphQL::Query::Context]
-      def resolve_field_method(obj, ruby_kwargs, ctx)
-        if obj.object.is_a?(Hash)
-          inner_object = obj.object
-          if inner_object.key?(@method_sym)
-            inner_object[@method_sym]
-          else
-            inner_object[@method_str]
-          end
-        elsif obj.object.respond_to?(@method_sym)
-          if ruby_kwargs.any?
-            obj.object.public_send(@method_sym, **ruby_kwargs)
-          else
-            obj.object.public_send(@method_sym)
-          end
-        else
-          raise <<-ERR
-        Failed to implement #{@owner.graphql_name}.#{@name}, tried:
-
-        - `#{obj.class}##{@resolver_method}`, which did not exist
-        - `#{obj.object.class}##{@method_sym}`, which did not exist
-        - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
-
-        To implement this field, define one of the methods above (and check for typos)
-        ERR
-        end
-      end
-
       # @param ctx [GraphQL::Query::Context::FieldResolutionContext]
       def fetch_extra(extra_name, ctx)
         if extra_name != :path && extra_name != :ast_node && respond_to?(extra_name)
@@ -704,24 +653,52 @@ module GraphQL
         end
       end
 
-      def public_send_field(obj, ruby_kwargs, field_ctx)
-        query_ctx = field_ctx.query.context
-        with_extensions(obj, ruby_kwargs, query_ctx) do |extended_obj, extended_args|
+      def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
+        with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
           if @resolver_class
-            if extended_obj.is_a?(GraphQL::Schema::Object)
-              extended_obj = extended_obj.object
+            if obj.is_a?(GraphQL::Schema::Object)
+              obj = obj.object
             end
-            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx, field: self)
+            obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
           end
 
-          if extended_obj.respond_to?(@resolver_method)
-            if extended_args.any?
-              extended_obj.public_send(@resolver_method, **extended_args)
+          # Find a way to resolve this field, checking:
+          #
+          # - A method on the type instance;
+          # - Hash keys, if the wrapped object is a hash;
+          # - A method on the wrapped object;
+          # - Or, raise not implemented.
+          #
+          if obj.respond_to?(@resolver_method)
+            # Call the method with kwargs, if there are any
+            if ruby_kwargs.any?
+              obj.public_send(@resolver_method, **ruby_kwargs)
             else
-              extended_obj.public_send(@resolver_method)
+              obj.public_send(@resolver_method)
+            end
+          elsif obj.object.is_a?(Hash)
+            inner_object = obj.object
+            if inner_object.key?(@method_sym)
+              inner_object[@method_sym]
+            else
+              inner_object[@method_str]
+            end
+          elsif obj.object.respond_to?(@method_sym)
+            if ruby_kwargs.any?
+              obj.object.public_send(@method_sym, **ruby_kwargs)
+            else
+              obj.object.public_send(@method_sym)
             end
           else
-            resolve_field_method(extended_obj, extended_args, query_ctx)
+            raise <<-ERR
+          Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+
+          - `#{obj.class}##{@resolver_method}`, which did not exist
+          - `#{obj.object.class}##{@method_sym}`, which did not exist
+          - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+
+          To implement this field, define one of the methods above (and check for typos)
+          ERR
           end
         end
       end

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

@@ -31,6 +31,7 @@ module GraphQL
           elsif value.is_a?(GraphQL::Pagination::Connection)
             # update the connection with some things that may not have been provided
             value.context ||= context
+            value.parent ||= object.object
             value.first_value ||= arguments[:first]
             value.after_value ||= arguments[:after]
             value.last_value ||= arguments[:last]
@@ -41,7 +42,7 @@ module GraphQL
             value
           elsif context.schema.new_connections?
             wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
-            context.schema.connections.wrap(field, value, arguments, context, wrappers: wrappers)
+            context.schema.connections.wrap(field, object.object, value, arguments, context, wrappers: wrappers)
           else
             if object.is_a?(GraphQL::Schema::Object)
               object = object.object

data/lib/graphql/schema/input_object.rb

@@ -166,7 +166,10 @@ module GraphQL
             return result
           end
 
-          input = begin
+          # We're not actually _using_ the coerced result, we're just
+          # using these methods to make sure that the object will
+          # behave like a hash below, when we call `each` on it.
+          begin
             input.to_h
           rescue
             begin
@@ -179,25 +182,21 @@ module GraphQL
             end
           end
 
-          # Inject missing required arguments
-          missing_required_inputs = self.arguments.reduce({}) do |m, (argument_name, argument)|
-            if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
-              m[argument_name] = nil
-            end
+          visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m}
 
-            m
+          # Items in the input that are unexpected
+          input.each do |name, value|
+            if visible_arguments_map[name].nil?
+              result.add_problem("Field is not defined on #{self.graphql_name}", [name])
+            end
           end
 
-          input.merge(missing_required_inputs).each do |argument_name, value|
-            argument = warden.get_argument(self, argument_name)
-            # Items in the input that are unexpected
-            unless argument
-              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              next
+          # Items in the input that are expected, but have invalid values
+          visible_arguments_map.map do |name, argument|
+            argument_result = argument.type.validate_input(input[name], ctx)
+            if !argument_result.valid?
+              result.merge_result!(name, argument_result)
             end
-            # Items in the input that are expected, but have invalid values
-            argument_result = argument.type.validate_input(value, ctx)
-            result.merge_result!(argument_name, argument_result) unless argument_result.valid?
           end
 
           result

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

@@ -58,22 +58,6 @@ module GraphQL
           end
         end
 
-        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
-        def get_argument(argument_name)
-          a = own_arguments[argument_name]
-
-          if a || !self.is_a?(Class)
-            a
-          else
-            for ancestor in ancestors
-              if ancestor.respond_to?(:own_arguments) && a = ancestor.own_arguments[argument_name]
-                return a
-              end
-            end
-            nil
-          end
-        end
-
         # @param new_arg_class [Class] A class to use for building argument definitions
         def argument_class(new_arg_class = nil)
           self.class.argument_class(new_arg_class)

data/lib/graphql/schema/resolver.rb

@@ -250,6 +250,19 @@ module GraphQL
           @complexity || (superclass.respond_to?(:complexity) ? superclass.complexity : 1)
         end
 
+        def broadcastable(new_broadcastable)
+          @broadcastable = new_broadcastable
+        end
+
+        # @return [Boolean, nil]
+        def broadcastable?
+          if defined?(@broadcastable)
+            @broadcastable
+          else
+            (superclass.respond_to?(:broadcastable?) ? superclass.broadcastable? : nil)
+          end
+        end
+
         def field_options
           {
             type: type_expr,
@@ -261,6 +274,7 @@ module GraphQL
             null: null,
             complexity: complexity,
             extensions: extensions,
+            broadcastable: broadcastable?,
           }
         end
 

data/lib/graphql/schema/subscription.rb

@@ -93,11 +93,11 @@ module GraphQL
         raise UnsubscribedError
       end
 
+      READING_SCOPE = ::Object.new
       # Call this method to provide a new subscription_scope; OR
       # call it without an argument to get the subscription_scope
       # @param new_scope [Symbol]
       # @return [Symbol]
-      READING_SCOPE = ::Object.new
       def self.subscription_scope(new_scope = READING_SCOPE)
         if new_scope != READING_SCOPE
           @subscription_scope = new_scope

data/lib/graphql/schema/warden.rb

@@ -91,7 +91,6 @@ module GraphQL
 
       # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`, if it exists
       def get_field(parent_type, field_name)
-
         @visible_parent_fields ||= read_through do |type|
           read_through do |f_name|
             field_defn = @schema.get_field(type, f_name)
@@ -106,12 +105,6 @@ module GraphQL
         @visible_parent_fields[parent_type][field_name]
       end
 
-      # @return [GraphQL::Argument, nil] The argument named `argument_name` on `parent_type`, if it exists and is visible
-      def get_argument(parent_type, argument_name)
-        argument = parent_type.get_argument(argument_name)
-        return argument if argument && visible_argument?(argument)
-      end
-
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
         @visible_possible_types ||= read_through { |type_defn|

data/lib/graphql/static_validation/literal_validator.rb

@@ -95,17 +95,16 @@ module GraphQL
       def required_input_fields_are_present(type, ast_node)
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
-        required_field_names = type.arguments.each_value
-          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
+        required_field_names = @warden.arguments(type)
+          .select { |f| f.type.kind.non_null? }
           .map(&:name)
-
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
         if @context.schema.error_bubbling
           missing_required_field_names.empty? ? @valid_response : @invalid_response
         else
           results = missing_required_field_names.map do |name|
-            arg_type = @warden.get_argument(type, name).type
+            arg_type = @warden.arguments(type).find { |f| f.name == name }.type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
           merge_results(results)
@@ -113,12 +112,13 @@ module GraphQL
       end
 
       def present_input_field_values_are_valid(type, ast_node)
+        field_map = @warden.arguments(type).reduce({}) { |m, f| m[f.name] = f; m}
         results = ast_node.arguments.map do |value|
-          field = @warden.get_argument(type, value.name)
+          field = field_map[value.name]
           # we want to call validate on an argument even if it's an invalid one
           # so that our raise exception is on it instead of the entire InputObject
-          field_type = field && field.type
-          recursively_validate(value.value, field_type)
+          type = field && field.type
+          recursively_validate(value.value, type)
         end
         merge_results(results)
       end

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

@@ -5,7 +5,7 @@ module GraphQL
       def on_argument(node, parent)
         parent_defn = parent_definition(parent)
 
-        if parent_defn && context.warden.get_argument(parent_defn, node.name)
+        if parent_defn && context.warden.arguments(parent_defn).any? { |arg| arg.name == node.name }
           super
         elsif parent_defn
           kind_of_node = node_type(parent)

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

@@ -17,8 +17,8 @@ module GraphQL
 
       def assert_required_args(ast_node, defn)
         present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = defn.arguments.each_value
-          .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
+        required_argument_names = context.warden.arguments(defn)
+          .select { |a| a.type.kind.non_null? && !a.default_value? }
           .map(&:name)
 
         missing_names = required_argument_names - present_argument_names

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

@@ -26,7 +26,8 @@ module GraphQL
           context.field_definition
         end
 
-        parent_type = context.warden.get_argument(defn, parent_name(parent, defn))
+        parent_type = context.warden.arguments(defn)
+          .find{|f| f.name == parent_name(parent, defn) }
         parent_type ? parent_type.type.unwrap : nil
       end
 

data/lib/graphql/subscriptions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "securerandom"
+require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
@@ -7,6 +8,7 @@ if defined?(ActionCable)
   require "graphql/subscriptions/action_cable_subscriptions"
 end
 require "graphql/subscriptions/subscription_root"
+require "graphql/subscriptions/default_subscription_resolve_extension"
 
 module GraphQL
   class Subscriptions
@@ -29,14 +31,25 @@ module GraphQL
       defn.instrument(:field, instrumentation)
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
+      schema.add_subscription_extension_if_necessary
       nil
     end
 
     # @param schema [Class] the GraphQL schema this manager belongs to
-    def initialize(schema:, **rest)
+    def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
+      if broadcast
+        if !schema.using_ast_analysis?
+          raise ArgumentError, "`broadcast: true` requires AST analysis, add `using GraphQL::Analysis::AST` to your schema or see https://graphql-ruby.org/queries/ast_analysis.html."
+        end
+        schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
+      end
+      @default_broadcastable = default_broadcastable
       @schema = schema
     end
 
+    # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
+    attr_reader :default_broadcastable
+
     # Fetch subscriptions matching this field + arguments pair
     # And pass them off to the queue.
     # @param event_name [String]
@@ -77,15 +90,13 @@ module GraphQL
     # `event` was triggered on `object`, and `subscription_id` was subscribed,
     # so it should be updated.
     #
-    # Load `subscription_id`'s GraphQL data, re-evaluate the query, and deliver the result.
-    #
-    # This is where a queue may be inserted to push updates in the background.
+    # Load `subscription_id`'s GraphQL data, re-evaluate the query and return the result.
     #
     # @param subscription_id [String]
     # @param event [GraphQL::Subscriptions::Event] The event which was triggered
     # @param object [Object] The value for the subscription field
-    # @return [void]
-    def execute(subscription_id, event, object)
+    # @return [GraphQL::Query::Result]
+    def execute_update(subscription_id, event, object)
       # Lookup the saved data for this subscription
       query_data = read_subscription(subscription_id)
       if query_data.nil?
@@ -98,7 +109,7 @@ module GraphQL
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
       # Re-evaluate the saved query
-      result = @schema.execute(
+      @schema.execute(
         query: query_string,
         context: context,
         subscription_topic: event.topic,
@@ -106,13 +117,25 @@ module GraphQL
         variables: variables,
         root_value: object,
       )
-      deliver(subscription_id, result)
     rescue GraphQL::Schema::Subscription::NoUpdateError
       # This update was skipped in user code; do nothing.
+      nil
     rescue GraphQL::Schema::Subscription::UnsubscribedError
       # `unsubscribe` was called, clean up on our side
       # TODO also send `{more: false}` to client?
       delete_subscription(subscription_id)
+      nil
+    end
+
+    # Run the update query for this subscription and deliver it
+    # @see {#execute_update}
+    # @see {#deliver}
+    # @return [void]
+    def execute(subscription_id, event, object)
+      res = execute_update(subscription_id, event, object)
+      if !res.nil?
+        deliver(subscription_id, res)
+      end
     end
 
     # Event `event` occurred on `object`,
@@ -185,6 +208,16 @@ module GraphQL
       Schema::Member::BuildType.camelize(event_or_arg_name.to_s)
     end
 
+    # @return [Boolean] if true, then a query like this one would be broadcasted
+    def broadcastable?(query_str, **query_options)
+      query = GraphQL::Query.new(@schema, query_str, **query_options)
+      if !query.valid?
+        raise "Invalid query: #{query.validation_errors.map(&:to_h).inspect}"
+      end
+      GraphQL::Analysis::AST.analyze_query(query, @schema.query_analyzers)
+      query.context.namespace(:subscriptions)[:subscription_broadcastable]
+    end
+
     private
 
     # Recursively normalize `args` as belonging to `arg_owner`:

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -8,7 +8,7 @@ module GraphQL
     #
     # - No queueing system; ActiveJob should be added
     # - Take care to reload context when re-delivering the subscription. (see {Query#subscription_update?})
-    # - Avoid the async ActionCable adapter and use the redis or PostgreSQL adapters instead. Otherwise calling #trigger won't work from background jobs or the Rails console. 
+    # - Avoid the async ActionCable adapter and use the redis or PostgreSQL adapters instead. Otherwise calling #trigger won't work from background jobs or the Rails console.
     #
     # @example Adding ActionCableSubscriptions to your schema
     #   class MySchema < GraphQL::Schema
@@ -90,6 +90,7 @@ module GraphQL
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
+        @events = Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new { |h2, k2| h2[k2] = Concurrent::Array.new } }
         @serializer = serializer
         super
       end
@@ -120,10 +121,44 @@ module GraphQL
         channel.stream_from(stream)
         @subscriptions[subscription_id] = query
         events.each do |event|
-          channel.stream_from(EVENT_PREFIX + event.topic, coder: ActiveSupport::JSON) do |message|
-            execute(subscription_id, event, @serializer.load(message))
-            nil
+          # Setup a new listener to run all events with this topic in this process
+          setup_stream(channel, event)
+          # Add this event to the list of events to be updated
+          @events[event.topic][event.fingerprint] << event
+        end
+      end
+
+      # Every subscribing channel is listening here, but only one of them takes any action.
+      # This is so we can reuse payloads when possible, and make one payload to send to
+      # all subscribers.
+      #
+      # But the problem is, any channel could close at any time, so each channel has to
+      # be ready to take over the primary position.
+      #
+      # To make sure there's always one-and-only-one channel building payloads,
+      # let the listener belonging to the first event on the list be
+      # the one to build and publish payloads.
+      #
+      def setup_stream(channel, initial_event)
+        topic = initial_event.topic
+        channel.stream_from(EVENT_PREFIX + topic, coder: ActiveSupport::JSON) do |message|
+          object = @serializer.load(message)
+          events_by_fingerprint = @events[topic]
+          events_by_fingerprint.each do |_fingerprint, events|
+            if events.any? && events.first == initial_event
+              # The fingerprint has told us that this response should be shared by all subscribers,
+              # so just run it once, then deliver the result to every subscriber
+              first_event = events.first
+              first_subscription_id = first_event.context.fetch(:subscription_id)
+              result = execute_update(first_subscription_id, first_event, object)
+              # Having calculated the result _once_, send the same payload to all subscribers
+              events.each do |event|
+                subscription_id = event.context.fetch(:subscription_id)
+                deliver(subscription_id, result)
+              end
+            end
           end
+          nil
         end
       end
 
@@ -140,7 +175,16 @@ module GraphQL
 
       # The channel was closed, forget about it.
       def delete_subscription(subscription_id)
-        @subscriptions.delete(subscription_id)
+        query = @subscriptions.delete(subscription_id)
+        events = query.context.namespace(:subscriptions)[:events]
+        events.each do |event|
+          ev_by_fingerprint = @events[event.topic]
+          ev_for_fingerprint = ev_by_fingerprint[event.fingerprint]
+          ev_for_fingerprint.delete(event)
+          if ev_for_fingerprint.empty?
+            ev_by_fingerprint.delete(event.fingerprint)
+          end
+        end
       end
     end
   end

data/lib/graphql/subscriptions/broadcast_analyzer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Subscriptions
+    # Detect whether the current operation:
+    # - Is a subscription operation
+    # - Is completely broadcastable
+    #
+    # Assign the result to `context.namespace(:subscriptions)[:subscription_broadcastable]`
+    # @api private
+    # @see Subscriptions#broadcastable? for a public API
+    class BroadcastAnalyzer < GraphQL::Analysis::AST::Analyzer
+      def initialize(subject)
+        super
+        @default_broadcastable = subject.schema.subscriptions.default_broadcastable
+        # Maybe this will get set to false while analyzing
+        @subscription_broadcastable = true
+      end
+
+      # Only analyze subscription operations
+      def analyze?
+        @query.subscription?
+      end
+
+      def on_enter_field(node, parent, visitor)
+        if (@subscription_broadcastable == false) || visitor.skipping?
+          return
+        end
+
+        current_field = visitor.field_definition
+        apply_broadcastable(current_field)
+
+        current_type = visitor.parent_type_definition
+        if current_type.kind.interface?
+          pt = @query.possible_types(current_type)
+          pt.each do |object_type|
+            ot_field = @query.get_field(object_type, current_field.graphql_name)
+            if !ot_field
+              binding.pry
+            end
+            # Inherited fields would be exactly the same object;
+            # only check fields that are overrides of the inherited one
+            if ot_field && ot_field != current_field
+              apply_broadcastable(ot_field)
+            end
+          end
+        end
+      end
+
+      # Assign the result to context.
+      # (This method is allowed to return an error, but we don't need to)
+      # @return [void]
+      def result
+        query.context.namespace(:subscriptions)[:subscription_broadcastable] = @subscription_broadcastable
+        nil
+      end
+
+      private
+
+      # Modify `@subscription_broadcastable` based on `field_defn`'s configuration (and/or the default value)
+      def apply_broadcastable(field_defn)
+        current_field_broadcastable = field_defn.introspection? || field_defn.broadcastable?
+        case current_field_broadcastable
+        when nil
+          # If the value wasn't set, mix in the default value:
+          # - If the default is false and the current value is true, make it false
+          # - If the default is true and the current value is true, it stays true
+          # - If the default is false and the current value is false, keep it false
+          # - If the default is true and the current value is false, keep it false
+          @subscription_broadcastable = @subscription_broadcastable && @default_broadcastable
+        when false
+          # One non-broadcastable field is enough to make the whole subscription non-broadcastable
+          @subscription_broadcastable = false
+        when true
+          # Leave `@broadcastable_query` true if it's already true,
+          # but don't _set_ it to true if it was set to false by something else.
+          # Actually, just leave it!
+        else
+          raise ArgumentError, "Unexpected `.broadcastable?` value for #{field_defn.path}: #{current_field_broadcastable}"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module GraphQL
+  class Subscriptions
+    class DefaultSubscriptionResolveExtension < GraphQL::Subscriptions::SubscriptionRoot::Extension
+      def resolve(context:, object:, arguments:)
+        has_override_implementation = @field.resolver ||
+          object.respond_to?(@field.resolver_method)
+
+        if !has_override_implementation
+          if context.query.subscription_update?
+            object.object
+          else
+            context.skip
+          end
+        else
+          yield(object, arguments)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions/event.rb

@@ -6,7 +6,6 @@ module GraphQL
     # - Subscribed to by `subscription { ... }`
     # - Triggered by `MySchema.subscriber.trigger(name, arguments, obj)`
     #
-    # An array of `Event`s are passed to `store.register(query, events)`.
     class Event
       # @return [String] Corresponds to the Subscription root field name
       attr_reader :name
@@ -53,6 +52,22 @@ module GraphQL
         Serialize.dump_recursive([scope, name, sorted_h])
       end
 
+      # @return [String] a logical identifier for this event. (Stable when the query is broadcastable.)
+      def fingerprint
+        @fingerprint ||= begin
+          # When this query has been flagged as broadcastable,
+          # use a generalized, stable fingerprint so that
+          # duplicate subscriptions can be evaluated and distributed in bulk.
+          # (`@topic` includes field, args, and subscription scope already.)
+          if @context.namespace(:subscriptions)[:subscription_broadcastable]
+            "#{@topic}/#{@context.query.fingerprint}"
+          else
+            # not broadcastable, build a unique ID for this event
+            @context.schema.subscriptions.build_id
+          end
+        end
+      end
+
       class << self
         private
         def stringify_args(arg_owner, args)

data/lib/graphql/subscriptions/subscription_root.rb

@@ -2,9 +2,11 @@
 
 module GraphQL
   class Subscriptions
-    # Extend this module in your subscription root when using {GraphQL::Execution::Interpreter}.
+    # @api private
+    # @deprecated This module is no longer needed.
     module SubscriptionRoot
       def self.extended(child_cls)
+        warn "`extend GraphQL::Subscriptions::SubscriptionRoot` is no longer required; you can remove it from your Subscription type (#{child_cls})"
         child_cls.include(InstanceMethods)
       end
 

data/lib/graphql/tracing.rb

@@ -16,8 +16,6 @@ end
 module GraphQL
   # Library entry point for performance metric reporting.
   #
-  # __Warning:__ Installing/uninstalling tracers is not thread-safe. Do it during application boot only.
-  #
   # @example Sending custom events
   #   query.trace("my_custom_event", { ... }) do
   #     # do stuff ...
@@ -86,31 +84,6 @@ module GraphQL
       end
     end
 
-    class << self
-      # Install a tracer to receive events.
-      # @param tracer [<#trace(key, metadata)>]
-      # @return [void]
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def install(tracer)
-        warn("GraphQL::Tracing.install is deprecated, add it to the schema with `tracer(my_tracer)` instead.")
-        if !tracers.include?(tracer)
-          @tracers << tracer
-        end
-      end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def uninstall(tracer)
-        @tracers.delete(tracer)
-      end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def tracers
-        @tracers ||= []
-      end
-    end
-    # Initialize the array
-    tracers
-
     module NullTracer
       module_function
       def trace(k, v)

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.10.14"
+  VERSION = "1.11.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.14
+  version: 1.11.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -681,6 +681,8 @@ files:
 - lib/graphql/string_type.rb
 - lib/graphql/subscriptions.rb
 - lib/graphql/subscriptions/action_cable_subscriptions.rb
+- lib/graphql/subscriptions/broadcast_analyzer.rb
+- lib/graphql/subscriptions/default_subscription_resolve_extension.rb
 - lib/graphql/subscriptions/event.rb
 - lib/graphql/subscriptions/instrumentation.rb
 - lib/graphql/subscriptions/serialize.rb