graphql 1.10.13 → 1.11.3

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -58,7 +58,8 @@ module GraphQL
             resolver_fields.each do |name, f|
               # Reattach the already-defined field here
               # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              add_field(f)
+              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+              add_field(f, method_conflict_warning: false)
             end
           end
         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/union.rb

@@ -14,6 +14,7 @@ module GraphQL
         def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
             types.each do |t|
+              assert_valid_union_member(t)
               type_memberships << type_membership_class.new(self, t, **options)
             end
           else
@@ -55,6 +56,34 @@ module GraphQL
         def type_memberships
           @type_memberships ||= []
         end
+
+        # Update a type membership whose `.object_type` is a string or late-bound type
+        # so that the type membership's `.object_type` is the given `object_type`.
+        # (This is used for updating the union after the schema as lazily loaded the union member.)
+        # @api private
+        def assign_type_membership_object_type(object_type)
+          assert_valid_union_member(object_type)
+          type_memberships.each { |tm|
+            possible_type = tm.object_type
+            if possible_type.is_a?(String) && (possible_type == object_type.name)
+              # This is a match of Ruby class names, not graphql names,
+              # since strings are used to refer to constants.
+              tm.object_type = object_type
+            elsif possible_type.is_a?(LateBoundType) && possible_type.graphql_name == object_type.graphql_name
+              tm.object_type = object_type
+            end
+          }
+          nil
+        end
+
+        private
+
+        def assert_valid_union_member(type_defn)
+          if type_defn.is_a?(Module) && !type_defn.is_a?(Class)
+            # it's an interface type, defined as a module
+            raise ArgumentError, "Union possible_types can only be object types (not interface types), remove #{type_defn.graphql_name} (#{type_defn.inspect})"
+          end
+        end
       end
     end
   end

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)

data/lib/graphql/static_validation/literal_validator.rb

@@ -95,16 +95,17 @@ 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 = @warden.arguments(type)
-          .select { |f| f.type.kind.non_null? }
+        required_field_names = type.arguments.each_value
+          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
           .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.arguments(type).find { |f| f.name == name }.type
+            arg_type = @warden.get_argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
           merge_results(results)
@@ -112,13 +113,12 @@ 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 = field_map[value.name]
+          field = @warden.get_argument(type, 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
-          type = field && field.type
-          recursively_validate(value.value, type)
+          field_type = field && field.type
+          recursively_validate(value.value, field_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.arguments(parent_defn).any? { |arg| arg.name == node.name }
+        if parent_defn && context.warden.get_argument(parent_defn, 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 = context.warden.arguments(defn)
-          .select { |a| a.type.kind.non_null? && !a.default_value? }
+        required_argument_names = defn.arguments.each_value
+          .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
           .map(&:name)
 
         missing_names = required_argument_names - present_argument_names

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

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

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

@@ -126,8 +126,9 @@ module GraphQL
         node_variables
           .select { |name, usage| usage.declared? && !usage.used? }
           .each { |var_name, usage|
+            declared_by_error_name = usage.declared_by.name || "anonymous #{usage.declared_by.operation_type}"
             add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
-              "Variable $#{var_name} is declared by #{usage.declared_by.name} but not used",
+              "Variable $#{var_name} is declared by #{declared_by_error_name} but not used",
               nodes: usage.declared_by,
               path: usage.path,
               name: var_name,
@@ -139,8 +140,9 @@ module GraphQL
         node_variables
           .select { |name, usage| usage.used? && !usage.declared? }
           .each { |var_name, usage|
+            used_by_error_name = usage.used_by.name || "anonymous #{usage.used_by.operation_type}"
             add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
-              "Variable $#{var_name} is used by #{usage.used_by.name} but not declared",
+              "Variable $#{var_name} is used by #{used_by_error_name} but not declared",
               nodes: usage.ast_node,
               path: usage.path,
               name: var_name,

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,27 +121,81 @@ 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
 
       # Return the query from "storage" (in memory)
       def read_subscription(subscription_id)
         query = @subscriptions[subscription_id]
-        {
-          query_string: query.query_string,
-          variables: query.provided_variables,
-          context: query.context.to_h,
-          operation_name: query.operation_name,
-        }
+        if query.nil?
+          # This can happen when a subscription is triggered from an unsubscribed channel,
+          # see https://github.com/rmosolgo/graphql-ruby/issues/2478.
+          # (This `nil` is handled by `#execute_update`)
+          nil
+        else
+          {
+            query_string: query.query_string,
+            variables: query.provided_variables,
+            context: query.context.to_h,
+            operation_name: query.operation_name,
+          }
+        end
       end
 
       # The channel was closed, forget about it.
       def delete_subscription(subscription_id)
-        @subscriptions.delete(subscription_id)
+        query = @subscriptions.delete(subscription_id)
+        # This can be `nil` when `.trigger` happens inside an unsubscribed ActionCable channel,
+        # see https://github.com/rmosolgo/graphql-ruby/issues/2478
+        if query
+          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
   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