graphql 2.6.11 → 2.6.13

data/lib/graphql/subscriptions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "securerandom"
 require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
@@ -21,7 +22,7 @@ module GraphQL
     class SubscriptionScopeMissingError < GraphQL::Error
     end
 
-    # @see {Subscriptions#initialize} for options, concrete implementations may add options.
+    # See [GraphQL::Subscriptions](rdoc-ref:GraphQL::Subscriptions) for the base options; concrete implementations may add options.
     def self.use(defn, options = {})
       schema = defn.is_a?(Class) ? defn : defn.target
 
@@ -35,8 +36,13 @@ module GraphQL
       nil
     end
 
-    # @param schema [Class] the GraphQL schema this manager belongs to
-    # @param validate_update [Boolean] If false, then validation is skipped when executing updates
+    # **Parameters**
+    #
+    # - `schema` (`Class`) — the GraphQL schema this manager belongs to
+    # - `validate_update` (`Boolean`) — If false, then validation is skipped when executing updates
+    #
+    # :call-seq:
+    #   initialize(Class schema:, bool validate_update:, broadcast:, default_broadcastable:, **rest)
     def initialize(schema:, validate_update: true, broadcast: false, default_broadcastable: false, **rest)
       if broadcast
         schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
@@ -46,17 +52,28 @@ module GraphQL
       @validate_update = validate_update
     end
 
-    # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
+    # **Returns**
+    #
+    # - `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]
-    # @param args [Hash<String, Symbol => Object]
-    # @param object [Object]
-    # @param scope [Symbol, String]
-    # @param context [Hash]
-    # @return [void]
+    #
+    # **Parameters**
+    #
+    # - `event_name` (`String`)
+    # - `args` (`Hash<String, Symbol => Object>`) — Arguments passed to the subscription resolver
+    # - `object` (`Object`)
+    # - `scope` (`Symbol, String`)
+    # - `context` (`Hash`)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   trigger(String event_name, Hash[String | Symbol, Object] args, Object object, Symbol | String scope:, Hash context:) -> void
     def trigger(event_name, args, object, scope: nil, context: {})
       # Make something as context-like as possible, even though there isn't a current query:
       dummy_query = @schema.query_class.new(@schema, "{ __typename }", validate: false, context: context)
@@ -97,10 +114,18 @@ module GraphQL
     #
     # 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 [GraphQL::Query::Result]
+    # **Parameters**
+    #
+    # - `subscription_id` (`String`)
+    # - `event` (`GraphQL::Subscriptions::Event`) — The event which was triggered
+    # - `object` (`Object`) — The value for the subscription field
+    #
+    # **Returns**
+    #
+    # - `GraphQL::Query::Result`
+    #
+    # :call-seq:
+    #   execute_update(String subscription_id, GraphQL::Subscriptions::Event event, Object object) -> GraphQL::Query::Result
     def execute_update(subscription_id, event, object)
       # Lookup the saved data for this subscription
       query_data = read_subscription(subscription_id)
@@ -146,15 +171,26 @@ module GraphQL
     # Define this method to customize whether to validate
     # this subscription when executing an update.
     #
-    # @return [Boolean] defaults to `true`, or false if `validate: false` is provided.
+    # **Returns**
+    #
+    # - `Boolean` — defaults to `true`, or false if `validate: false` is provided.
+    #
+    # :call-seq:
+    #   validate_update?(query:, context:, root_value:, subscription_topic:, operation_name:, variables:) -> bool
     def validate_update?(query:, context:, root_value:, subscription_topic:, operation_name:, variables:)
       @validate_update
     end
 
     # Run the update query for this subscription and deliver it
-    # @see {#execute_update}
-    # @see {#deliver}
-    # @return [void]
+    # See [execute_update](rdoc-ref:#execute_update)
+    # See [deliver](rdoc-ref:#deliver)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   execute(subscription_id, event, object) -> void
     def execute(subscription_id, event, object)
       res = execute_update(subscription_id, event, object)
       if !res.nil?
@@ -171,48 +207,98 @@ module GraphQL
 
     # Event `event` occurred on `object`,
     # Update all subscribers.
-    # @param event [Subscriptions::Event]
-    # @param object [Object]
-    # @return [void]
+    #
+    # **Parameters**
+    #
+    # - `event` (`Subscriptions::Event`)
+    # - `object` (`Object`)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   execute_all(Subscriptions::Event event, Object object) -> void
     def execute_all(event, object)
       raise GraphQL::RequiredImplementationMissingError
     end
 
     # The system wants to send an update to this subscription.
     # Read its data and return it.
-    # @param subscription_id [String]
-    # @return [Hash] Containing required keys
+    #
+    # **Parameters**
+    #
+    # - `subscription_id` (`String`)
+    #
+    # **Returns**
+    #
+    # - `Hash` — Containing required keys
+    #
+    # :call-seq:
+    #   read_subscription(String subscription_id) -> Hash
     def read_subscription(subscription_id)
       raise GraphQL::RequiredImplementationMissingError
     end
 
     # A subscription query was re-evaluated, returning `result`.
     # The result should be send to `subscription_id`.
-    # @param subscription_id [String]
-    # @param result [Hash]
-    # @return [void]
+    #
+    # **Parameters**
+    #
+    # - `subscription_id` (`String`)
+    # - `result` (`Hash`)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   deliver(String subscription_id, Hash result) -> void
     def deliver(subscription_id, result)
       raise GraphQL::RequiredImplementationMissingError
     end
 
     # `query` was executed and found subscriptions to `events`.
     # Update the database to reflect this new state.
-    # @param query [GraphQL::Query]
-    # @param events [Array<GraphQL::Subscriptions::Event>]
-    # @return [void]
+    #
+    # **Parameters**
+    #
+    # - `query` (`GraphQL::Query`)
+    # - `events` (`Array<GraphQL::Subscriptions::Event>`)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   write_subscription(GraphQL::Query query, Array[GraphQL::Subscriptions::Event] events) -> void
     def write_subscription(query, events)
       raise GraphQL::RequiredImplementationMissingError
     end
 
     # A subscription was terminated server-side.
     # Clean up the database.
-    # @param subscription_id [String]
-    # @return void.
+    #
+    # **Parameters**
+    #
+    # - `subscription_id` (`String`)
+    #
+    # **Returns**
+    #
+    # - `Object` — void.
+    #
+    # :call-seq:
+    #   delete_subscription(String subscription_id) -> Object
     def delete_subscription(subscription_id)
       raise GraphQL::RequiredImplementationMissingError
     end
 
-    # @return [String] A new unique identifier for a subscription
+    # **Returns**
+    #
+    # - `String` — A new unique identifier for a subscription
+    #
+    # :call-seq:
+    #   build_id() -> String
     def build_id
       SecureRandom.uuid
     end
@@ -223,13 +309,26 @@ module GraphQL
     # By default, it converts the identifier to camelcase.
     # Override this in a subclass to change the transformation.
     #
-    # @param event_or_arg_name [String, Symbol]
-    # @return [String]
+    # **Parameters**
+    #
+    # - `event_or_arg_name` (`String, Symbol`)
+    #
+    # **Returns**
+    #
+    # - `String`
+    #
+    # :call-seq:
+    #   normalize_name(String | Symbol event_or_arg_name) -> String
     def normalize_name(event_or_arg_name)
       Schema::Member::BuildType.camelize(event_or_arg_name.to_s)
     end
 
-    # @return [Boolean] if true, then a query like this one would be broadcasted
+    # **Returns**
+    #
+    # - `Boolean` — if true, then a query like this one would be broadcasted
+    #
+    # :call-seq:
+    #   broadcastable?(query_str, **query_options) -> bool
     def broadcastable?(query_str, **query_options)
       query = @schema.query_class.new(@schema, query_str, **query_options)
       if !query.valid?
@@ -240,8 +339,17 @@ module GraphQL
     end
 
     # Called during execution when a new `subscription ...` operation is received
-    # @param query [GraphQL::Query]
-    # @return [void]
+    #
+    # **Parameters**
+    #
+    # - `query` (`GraphQL::Query`)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   initialize_subscriptions(GraphQL::Query query) -> void
     def initialize_subscriptions(query)
       subs_namespace = query.context.namespace(:subscriptions)
       subs_namespace[:events] = []
@@ -250,8 +358,17 @@ module GraphQL
     end
 
     # Called during execution when a subscription operation has finished
-    # @param query [GraphQL::Query]
-    # @return [void]
+    #
+    # **Parameters**
+    #
+    # - `query` (`GraphQL::Query`)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   finish_subscriptions(GraphQL::Query query) -> void
     def finish_subscriptions(query)
       if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
         write_subscription(query, events)
@@ -278,19 +395,30 @@ module GraphQL
 
     # Recursively normalize `args` as belonging to `arg_owner`:
     # - convert symbols to strings,
-    # - if needed, camelize the string (using {#normalize_name})
-    # @param arg_owner [GraphQL::Field, GraphQL::BaseType]
-    # @param args [Hash, Array, Any] some GraphQL input value to coerce as `arg_owner`
-    # @return [Any] normalized arguments value
+    # - if needed, camelize the string (using [normalize name](rdoc-ref:#normalize_name))
+    #
+    # **Parameters**
+    #
+    # - `arg_owner` (`GraphQL::Field, GraphQL::BaseType`)
+    # - `args` (`Hash, Array, Any`) — some GraphQL input value to coerce as `arg_owner`
+    #
+    # **Returns**
+    #
+    # - `Any` — normalized arguments value
+    #
+    # :call-seq:
+    #   normalize_arguments(event_name, GraphQL::Field | GraphQL::BaseType arg_owner, Hash | Array | Any args, context) -> Any
     def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
       when GraphQL::Schema::Field, Class
         return args if args.nil?
 
+        arg_owner = arg_owner #: as GraphQL::Schema::Field | GraphQL::Schema::Member::type_definition
         if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
           # it's a type, but not an input object
           return args
         end
+        arg_owner = arg_owner #: as GraphQL::Schema::Field | singleton(GraphQL::Schema::InputObject)
         normalized_args = {}
         missing_arg_names = []
         args.each do |k, v|
@@ -329,10 +457,8 @@ module GraphQL
         if !missing_arg_names.empty?
           arg_owner_name = if arg_owner.is_a?(GraphQL::Schema::Field)
             arg_owner.path
-          elsif arg_owner.is_a?(Class)
-            arg_owner.graphql_name
           else
-            arg_owner.to_s
+            arg_owner.graphql_name
           end
           raise InvalidTriggerError, "Can't trigger Subscription.#{event_name}, received undefined arguments: #{missing_arg_names.join(", ")}. (Should match arguments of #{arg_owner_name}.)"
         end

data/lib/graphql/testing/helpers.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Testing
+    #--
+    # @requires_ancestor: Kernel
     module Helpers
-      # @param schema_class [Class<GraphQL::Schema>]
-      # @return [Module] A helpers module which always uses the given schema
+      # **Parameters**
+      #
+      # - `schema_class` (`Class<GraphQL::Schema>`)
+      #
+      # **Returns**
+      #
+      # - `Module` — A helpers module which always uses the given schema
+      #
+      # :call-seq:
+      #   for(Class[GraphQL::Schema] schema_class) -> Module
       def self.for(schema_class)
         SchemaHelpers.for(schema_class)
       end
@@ -40,6 +51,8 @@ module GraphQL
       end
 
       def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil, visibility_profile: nil)
+        ast_node = ast_node #: GraphQL::Language::Nodes::Field?
+        lookahead = lookahead #: GraphQL::Execution::Lookahead?
         type_name, *field_names = field_path.split(".")
         dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context, visibility_profile: visibility_profile)
         query_context = dummy_query.context
@@ -144,9 +157,9 @@ module GraphQL
           super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context, visibility_profile: visibility_profile)
         end
 
-        def with_resolution_context(*args, **kwargs, &block)
+        def with_resolution_context(**kwargs, &block)
           # schema will be added later
-          super(nil, *args, **kwargs, &block)
+          super(nil, **kwargs, &block)
         end
 
         def self.for(schema_class)

data/lib/graphql/testing/mock_action_cable.rb

@@ -1,49 +1,62 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Testing
     # A stub implementation of ActionCable.
     # Any methods to support the mock backend have `mock` in the name.
     #
-    # @example Configuring your schema to use MockActionCable in the test environment
-    #   class MySchema < GraphQL::Schema
-    #     # Use MockActionCable in test:
-    #     use GraphQL::Subscriptions::ActionCableSubscriptions,
-    #       action_cable: Rails.env.test? ? GraphQL::Testing::MockActionCable : ActionCable
-    #   end
+    # **Examples**
     #
-    # @example Clearing old data before each test
-    #   setup do
-    #     GraphQL::Testing::MockActionCable.clear_mocks
-    #   end
+    # **Example: Configuring your schema to use MockActionCable in the test environment**
     #
-    # @example Using MockActionCable in a test case
-    #   # Create a channel to use in the test, pass it to GraphQL
-    #   mock_channel = GraphQL::Testing::MockActionCable.get_mock_channel
-    #   ActionCableTestSchema.execute("subscription { newsFlash { text } }", context: { channel: mock_channel })
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   # Use MockActionCable in test:
+    #   use GraphQL::Subscriptions::ActionCableSubscriptions,
+    #     action_cable: Rails.env.test? ? GraphQL::Testing::MockActionCable : ActionCable
+    # end
+    # ```
     #
-    #   # Trigger a subscription update
-    #   ActionCableTestSchema.subscriptions.trigger(:news_flash, {}, {text: "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"})
+    # **Example: Clearing old data before each test**
     #
-    #   # Check messages on the channel
-    #   expected_msg = {
-    #     result: {
-    #       "data" => {
-    #         "newsFlash" => {
-    #           "text" => "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"
-    #         }
-    #       }
-    #     },
-    #     more: true,
-    #   }
-    #   assert_equal [expected_msg], mock_channel.mock_broadcasted_messages
+    # ```ruby
+    # setup do
+    #   GraphQL::Testing::MockActionCable.clear_mocks
+    # end
+    # ```
+    #
+    # **Example: Using MockActionCable in a test case**
+    #
+    # ```ruby
+    # # Create a channel to use in the test, pass it to GraphQL
+    # mock_channel = GraphQL::Testing::MockActionCable.get_mock_channel
+    # ActionCableTestSchema.execute("subscription { newsFlash { text } }", context: { channel: mock_channel })
     #
+    # # Trigger a subscription update
+    # ActionCableTestSchema.subscriptions.trigger(:news_flash, {}, {text: "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"})
+    #
+    # # Check messages on the channel
+    # expected_msg = {
+    #   result: {
+    #     "data" => {
+    #       "newsFlash" => {
+    #         "text" => "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"
+    #       }
+    #     }
+    #   },
+    #   more: true,
+    # }
+    # assert_equal [expected_msg], mock_channel.mock_broadcasted_messages
+    # ```
     class MockActionCable
       class MockChannel
         def initialize
           @mock_broadcasted_messages = []
         end
 
-        # @return [Array<Hash>] Payloads "sent" to this channel by GraphQL-Ruby
+        # **Returns**
+        #
+        # - `Array<Hash>` — Payloads "sent" to this channel by GraphQL-Ruby
         attr_reader :mock_broadcasted_messages
 
         # Called by ActionCableSubscriptions. Implements a Rails API.
@@ -55,8 +68,7 @@ module GraphQL
       end
 
       # Used by mock code
-      # @api private
-      class MockStream
+      class MockStream # :nodoc:
         def initialize
           @mock_channels = {}
         end
@@ -96,12 +108,22 @@ module GraphQL
 
         # Use this as `context[:channel]` to simulate an ActionCable channel
         #
-        # @return [GraphQL::Testing::MockActionCable::MockChannel]
+        # **Returns**
+        #
+        # - `GraphQL::Testing::MockActionCable::MockChannel`
+        #
+        # :call-seq:
+        #   get_mock_channel() -> GraphQL::Testing::MockActionCable::MockChannel
         def get_mock_channel
           MockChannel.new
         end
 
-        # @return [Array<String>] Streams that currently have subscribers
+        # **Returns**
+        #
+        # - `Array<String>` — Streams that currently have subscribers
+        #
+        # :call-seq:
+        #   mock_stream_names() -> Array[String]
         def mock_stream_names
           @mock_streams.keys
         end

data/lib/graphql/testing.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/testing/helpers"
 require "graphql/testing/mock_action_cable"

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/notifications_trace"
 
@@ -6,17 +7,24 @@ module GraphQL
   module Tracing
     # This implementation forwards events to ActiveSupport::Notifications with a `graphql` suffix.
     #
-    # @example Sending execution events to ActiveSupport::Notifications
-    #   class MySchema < GraphQL::Schema
-    #     trace_with(GraphQL::Tracing::ActiveSupportNotificationsTrace)
-    #   end
+    # **Examples**
     #
-    # @example Subscribing to GraphQL events with ActiveSupport::Notifications
-    #   ActiveSupport::Notifications.subscribe(/graphql/) do |event|
-    #     pp event.name
-    #     pp event.payload
-    #   end
+    # **Example: Sending execution events to ActiveSupport::Notifications**
     #
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   trace_with(GraphQL::Tracing::ActiveSupportNotificationsTrace)
+    # end
+    # ```
+    #
+    # **Example: Subscribing to GraphQL events with ActiveSupport::Notifications**
+    #
+    # ```ruby
+    # ActiveSupport::Notifications.subscribe(/graphql/) do |event|
+    #   pp event.name
+    #   pp event.payload
+    # end
+    # ```
     module ActiveSupportNotificationsTrace
       include NotificationsTrace
       def initialize(engine: ActiveSupport::Notifications, **rest)

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "graphql/tracing/notifications_tracing"
 
@@ -7,7 +8,7 @@ module GraphQL
     # This implementation forwards events to ActiveSupport::Notifications
     # with a `graphql` suffix.
     #
-    # @see KEYS for event names
+    # See [KEYS](rdoc-ref:KEYS) for event names
     module ActiveSupportNotificationsTracing
       # A cache of frequently-used keys to avoid needless string allocations
       KEYS = NotificationsTracing::KEYS

data/lib/graphql/tracing/appoptics_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/platform_trace"
 
@@ -10,7 +11,7 @@ module GraphQL
     #
     # There are 4 configurations available. They can be set in the
     # appoptics_apm config file or in code. Please see:
-    # {https://docs.appoptics.com/kb/apm_tracing/ruby/configure}
+    # https://docs.appoptics.com/kb/apm_tracing/ruby/configure
     #
     #     AppOpticsAPM::Config[:graphql][:enabled] = true|false
     #     AppOpticsAPM::Config[:graphql][:transaction_name]  = true|false

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/platform_tracing"
 
@@ -10,7 +11,7 @@ module GraphQL
     #
     # There are 4 configurations available. They can be set in the
     # appoptics_apm config file or in code. Please see:
-    # {https://docs.appoptics.com/kb/apm_tracing/ruby/configure}
+    # https://docs.appoptics.com/kb/apm_tracing/ruby/configure
     #
     #     AppOpticsAPM::Config[:graphql][:enabled] = true|false
     #     AppOpticsAPM::Config[:graphql][:transaction_name]  = true|false

data/lib/graphql/tracing/appsignal_trace.rb

@@ -1,19 +1,28 @@
 # frozen_string_literal: true
+# typed: ignore
 require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
     # Instrumentation for reporting GraphQL-Ruby times to Appsignal.
     #
-    # @example Installing the tracer
-    #   class MySchema < GraphQL::Schema
-    #     trace_with GraphQL::Tracing::AppsignalTrace
-    #   end
+    # **Examples**
+    #
+    # **Example: Installing the tracer**
+    #
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   trace_with GraphQL::Tracing::AppsignalTrace
+    # end
+    # ```
     AppsignalTrace = MonitorTrace.create_module("appsignal")
     module AppsignalTrace
-      # @param set_action_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
-      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
-      #   It can also be specified per-query with `context[:set_appsignal_action_name]`.
+      # **Parameters**
+      #
+      # - `set_action_name` (`Boolean`) — If true, the GraphQL operation name will be used as the transaction name. This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing. It can also be specified per-query with `context[:set_appsignal_action_name]`.
+      #
+      # :call-seq:
+      #   initialize(bool set_action_name:, **rest)
       def initialize(set_action_name: false, **rest)
         rest[:set_transaction_name] ||= set_action_name
         setup_appsignal_monitor(**rest)

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "graphql/tracing/platform_tracing"
 
@@ -16,9 +17,12 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
-      # @param set_action_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
-      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
-      #   It can also be specified per-query with `context[:set_appsignal_action_name]`.
+      # **Parameters**
+      #
+      # - `set_action_name` (`Boolean`) — If true, the GraphQL operation name will be used as the transaction name. This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing. It can also be specified per-query with `context[:set_appsignal_action_name]`.
+      #
+      # :call-seq:
+      #   initialize(options)
       def initialize(options = {})
         @set_action_name = options.fetch(:set_action_name, false)
         super

data/lib/graphql/tracing/call_legacy_tracers.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Tracing