graphql 1.12.23 → 1.13.3

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

@@ -34,16 +34,16 @@ module GraphQL
         parent_type = get_parent_type(context, parent)
         return unless parent_type && parent_type.kind.input_object?
 
-        required_fields = parent_type.arguments
-          .select{|k,v| v.type.kind.non_null?}
-          .keys
+        required_fields = context.warden.arguments(parent_type)
+          .select{|arg| arg.type.kind.non_null?}
+          .map(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)
         missing_fields = required_fields - present_fields
 
         missing_fields.each do |missing_field|
           path = [*context.path, missing_field]
-          missing_field_type = parent_type.arguments[missing_field].type
+          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
           add_error(RequiredInputObjectAttributesArePresentError.new(
             "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,

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

@@ -22,15 +22,15 @@ module GraphQL
         node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
         if node_values.any?
-          arguments = case parent
+          argument_owner = case parent
           when GraphQL::Language::Nodes::Field
-            context.field_definition.arguments
+            context.field_definition
           when GraphQL::Language::Nodes::Directive
-            context.directive_definition.arguments
+            context.directive_definition
           when GraphQL::Language::Nodes::InputObject
             arg_type = context.argument_definition.type.unwrap
             if arg_type.kind.input_object?
-              arguments = arg_type.arguments
+              arg_type
             else
               # This is some kind of error
               nil
@@ -43,7 +43,7 @@ module GraphQL
             var_defn_ast = @declared_variables[node_value.name]
             # Might be undefined :(
             # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
-            var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast)
+            var_defn_ast && argument_owner && validate_usage(argument_owner, node, var_defn_ast)
           end
         end
         super
@@ -51,7 +51,7 @@ module GraphQL
 
       private
 
-      def validate_usage(arguments, arg_node, ast_var)
+      def validate_usage(argument_owner, arg_node, ast_var)
         var_type = context.schema.type_from_ast(ast_var.type, context: context)
         if var_type.nil?
           return
@@ -65,9 +65,15 @@ module GraphQL
           end
         end
 
-        arg_defn = arguments[arg_node.name]
+        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
         arg_defn_type = arg_defn.type
 
+        # If the argument is non-null, but it was given a default value,
+        # then treat it as nullable in practice, see https://github.com/rmosolgo/graphql-ruby/issues/3793
+        if arg_defn_type.non_null? && arg_defn.default_value?
+          arg_defn_type = arg_defn_type.of_type
+        end
+
         var_inner_type = var_type.unwrap
         arg_inner_type = arg_defn_type.unwrap
 

data/lib/graphql/string_type.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::STRING_TYPE = GraphQL::Types::String.graphql_definition
+GraphQL::STRING_TYPE = GraphQL::Types::String.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -170,10 +170,12 @@ module GraphQL
               first_subscription_id = first_event.context.fetch(:subscription_id)
               object ||= load_action_cable_message(message, first_event.context)
               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)
+              if !result.nil?
+                # 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
           end
@@ -214,6 +216,8 @@ module GraphQL
       # The channel was closed, forget about it.
       def delete_subscription(subscription_id)
         query = @subscriptions.delete(subscription_id)
+        # In case this came from the server, tell the client to unsubscribe:
+        @action_cable.server.broadcast(stream_subscription_name(subscription_id), { more: false })
         # This can be `nil` when `.trigger` happens inside an unsubscribed ActionCable channel,
         # see https://github.com/rmosolgo/graphql-ruby/issues/2478
         if query

data/lib/graphql/subscriptions/event.rb

@@ -23,15 +23,23 @@ module GraphQL
         @arguments = arguments
         @context = context
         field ||= context.field
-        scope_val = scope || (context && field.subscription_scope && context[field.subscription_scope])
+        scope_key = field.subscription_scope
+        scope_val = scope || (context && scope_key && context[scope_key])
+        if scope_key &&
+            (subscription = field.resolver) &&
+            (subscription.respond_to?(:subscription_scope_optional?)) &&
+            !subscription.subscription_scope_optional? &&
+            scope_val.nil?
+          raise Subscriptions::SubscriptionScopeMissingError, "#{field.path} (#{subscription}) requires a `scope:` value to trigger updates (Set `subscription_scope ..., optional: true` to disable this requirement)"
+        end
 
-        @topic = self.class.serialize(name, arguments, field, scope: scope_val)
+        @topic = self.class.serialize(name, arguments, field, scope: scope_val, context: context)
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(_name, arguments, field, scope:)
+      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext)
         subscription = field.resolver || GraphQL::Schema::Subscription
-        normalized_args = stringify_args(field, arguments.to_h)
+        normalized_args = stringify_args(field, arguments.to_h, context)
         subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
 
@@ -83,7 +91,7 @@ module GraphQL
           end
         end
 
-        def stringify_args(arg_owner, args)
+        def stringify_args(arg_owner, args, context)
           arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
           case args
           when Hash
@@ -91,13 +99,13 @@ module GraphQL
             args.each do |k, v|
               arg_name = k.to_s
               camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
-              arg_defn = get_arg_definition(arg_owner, camelized_arg_name)
+              arg_defn = get_arg_definition(arg_owner, camelized_arg_name, context)
 
               if arg_defn
                 normalized_arg_name = camelized_arg_name
               else
                 normalized_arg_name = arg_name
-                arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
+                arg_defn = get_arg_definition(arg_owner, normalized_arg_name, context)
               end
               arg_base_type = arg_defn.type.unwrap
               # In the case where the value being emitted is seen as a "JSON"
@@ -113,22 +121,22 @@ module GraphQL
                 end
                 next_args[normalized_arg_name] = sorted_value.respond_to?(:to_json) ? sorted_value.to_json : sorted_value
               else
-                next_args[normalized_arg_name] = stringify_args(arg_base_type, v)
+                next_args[normalized_arg_name] = stringify_args(arg_base_type, v, context)
               end
             end
             # Make sure they're deeply sorted
             next_args.sort.to_h
           when Array
-            args.map { |a| stringify_args(arg_owner, a) }
+            args.map { |a| stringify_args(arg_owner, a, context) }
           when GraphQL::Schema::InputObject
-            stringify_args(arg_owner, args.to_h)
+            stringify_args(arg_owner, args.to_h, context)
           else
             args
           end
         end
 
-        def get_arg_definition(arg_owner, arg_name)
-          arg_owner.arguments[arg_name] || arg_owner.arguments.each_value.find { |v| v.keyword.to_s == arg_name }
+        def get_arg_definition(arg_owner, arg_name, context)
+          arg_owner.get_argument(arg_name, context) || arg_owner.arguments(context).each_value.find { |v| v.keyword.to_s == arg_name }
         end
       end
     end

data/lib/graphql/subscriptions/serialize.rb

@@ -71,9 +71,17 @@ module GraphQL
               when SYMBOL_KEY
                 value[SYMBOL_KEY].to_sym
               when TIMESTAMP_KEY
-                timestamp_class_name, timestamp_s = value[TIMESTAMP_KEY]
+                timestamp_class_name, *timestamp_args = value[TIMESTAMP_KEY]
                 timestamp_class = Object.const_get(timestamp_class_name)
-                timestamp_class.strptime(timestamp_s, TIMESTAMP_FORMAT)
+                if defined?(ActiveSupport::TimeWithZone) && timestamp_class <= ActiveSupport::TimeWithZone
+                  zone_name, timestamp_s = timestamp_args
+                  zone = ActiveSupport::TimeZone[zone_name]
+                  raise "Zone #{zone_name} not found, unable to deserialize" unless zone
+                  zone.strptime(timestamp_s, TIMESTAMP_FORMAT)
+                else
+                  timestamp_s = timestamp_args.first
+                  timestamp_class.strptime(timestamp_s, TIMESTAMP_FORMAT)
+                end
               when OPEN_STRUCT_KEY
                 ostruct_values = load_value(value[OPEN_STRUCT_KEY])
                 OpenStruct.new(ostruct_values)
@@ -123,6 +131,18 @@ module GraphQL
             { SYMBOL_KEY => obj.to_s }
           elsif obj.respond_to?(:to_gid_param)
             {GLOBALID_KEY => obj.to_gid_param}
+          elsif defined?(ActiveSupport::TimeWithZone) && obj.is_a?(ActiveSupport::TimeWithZone) && obj.class.name != Time.name
+            # This handles a case where Rails prior to 7 would
+            # make the class ActiveSupport::TimeWithZone return "Time" for
+            # its name. In Rails 7, it will now return "ActiveSupport::TimeWithZone",
+            # which happens to be incompatible with expectations we have
+            # with what a Time class supports ( notably, strptime in `load_value` ).
+            #
+            # This now passes along the name of the zone, such that a future deserialization
+            # of this string will use the correct time zone from the ActiveSupport TimeZone
+            # list to produce the time.
+            #
+            { TIMESTAMP_KEY => [obj.class.name, obj.time_zone.name, obj.strftime(TIMESTAMP_FORMAT)] }
           elsif obj.is_a?(Date) || obj.is_a?(Time)
             # DateTime extends Date; for TimeWithZone, call `.utc` first.
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }

data/lib/graphql/subscriptions.rb

@@ -16,6 +16,13 @@ module GraphQL
     class InvalidTriggerError < GraphQL::Error
     end
 
+    # Raised when either:
+    # - An initial subscription didn't have a value for `context[subscription_scope]`
+    # - Or, an update didn't pass `.trigger(..., scope:)`
+    # When raised, the initial subscription or update fails completely.
+    class SubscriptionScopeMissingError < GraphQL::Error
+    end
+
     # @see {Subscriptions#initialize} for options, concrete implementations may add options.
     def self.use(defn, options = {})
       schema = defn.is_a?(Class) ? defn : defn.target
@@ -76,7 +83,8 @@ module GraphQL
       end
 
       # Normalize symbol-keyed args to strings, try camelizing them
-      normalized_args = normalize_arguments(normalized_event_name, field, args)
+      # Should this accept a real context somehow?
+      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,
@@ -151,16 +159,6 @@ module GraphQL
     # @param object [Object]
     # @return [void]
     def execute_all(event, object)
-      each_subscription_id(event) do |subscription_id|
-        execute(subscription_id, event, object)
-      end
-    end
-
-    # Get each `subscription_id` subscribed to `event.topic` and yield them
-    # @param event [GraphQL::Subscriptions::Event]
-    # @yieldparam subscription_id [String]
-    # @return [void]
-    def each_subscription_id(event)
       raise GraphQL::RequiredImplementationMissingError
     end
 
@@ -233,7 +231,7 @@ module GraphQL
     # @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
-    def normalize_arguments(event_name, arg_owner, args)
+    def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
       when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
         if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
@@ -244,19 +242,19 @@ module GraphQL
         missing_arg_names = []
         args.each do |k, v|
           arg_name = k.to_s
-          arg_defn = arg_owner.arguments[arg_name]
+          arg_defn = arg_owner.get_argument(arg_name, context)
           if arg_defn
             normalized_arg_name = arg_name
           else
             normalized_arg_name = normalize_name(arg_name)
-            arg_defn = arg_owner.arguments[normalized_arg_name]
+            arg_defn = arg_owner.get_argument(normalized_arg_name, context)
           end
 
           if arg_defn
             if arg_defn.loads
               normalized_arg_name = arg_defn.keyword.to_s
             end
-            normalized = normalize_arguments(event_name, arg_defn.type, v)
+            normalized = normalize_arguments(event_name, arg_defn.type, v, context)
             normalized_args[normalized_arg_name] = normalized
           else
             # Couldn't find a matching argument definition
@@ -266,12 +264,12 @@ module GraphQL
 
         # Backfill default values so that trigger arguments
         # match query arguments.
-        arg_owner.arguments.each do |name, arg_defn|
+        arg_owner.arguments(context).each do |_name, arg_defn|
           if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
             default_value = arg_defn.default_value
             # We don't have an underlying "object" here, so it can't call methods.
             # This is broken.
-            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: GraphQL::Query::NullContext)
+            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: context)
           end
         end
 
@@ -290,9 +288,9 @@ module GraphQL
 
         normalized_args
       when GraphQL::ListType, GraphQL::Schema::List
-        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
+        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
       when GraphQL::NonNullType, GraphQL::Schema::NonNull
-        normalize_arguments(event_name, arg_owner.of_type, args)
+        normalize_arguments(event_name, arg_owner.of_type, args, context)
       else
         args
       end

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'graphql/tracing/notifications_tracing'
+
 module GraphQL
   module Tracing
     # This implementation forwards events to ActiveSupport::Notifications
@@ -8,27 +10,11 @@ module GraphQL
     # @see KEYS for event names
     module ActiveSupportNotificationsTracing
       # A cache of frequently-used keys to avoid needless string allocations
-      KEYS = {
-        "lex" => "lex.graphql",
-        "parse" => "parse.graphql",
-        "validate" => "validate.graphql",
-        "analyze_multiplex" => "analyze_multiplex.graphql",
-        "analyze_query" => "analyze_query.graphql",
-        "execute_query" => "execute_query.graphql",
-        "execute_query_lazy" => "execute_query_lazy.graphql",
-        "execute_field" => "execute_field.graphql",
-        "execute_field_lazy" => "execute_field_lazy.graphql",
-        "authorized" => "authorized.graphql",
-        "authorized_lazy" => "authorized_lazy.graphql",
-        "resolve_type" => "resolve_type.graphql",
-        "resolve_type_lazy" => "resolve_type.graphql",
-      }
+      KEYS = NotificationsTracing::KEYS
+      NOTIFICATIONS_ENGINE = NotificationsTracing.new(ActiveSupport::Notifications) if defined?(ActiveSupport)
 
-      def self.trace(key, metadata)
-        prefixed_key = KEYS[key] || "#{key}.graphql"
-        ActiveSupport::Notifications.instrument(prefixed_key, metadata) do
-          yield
-        end
+      def self.trace(key, metadata, &blk)
+        NOTIFICATIONS_ENGINE.trace(key, metadata, &blk)
       end
     end
   end

data/lib/graphql/tracing/notifications_tracing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to a notification handler (i.e.
+    # ActiveSupport::Notifications or Dry::Monitor::Notifications)
+    # with a `graphql` suffix.
+    #
+    # @see KEYS for event names
+    class NotificationsTracing
+      # A cache of frequently-used keys to avoid needless string allocations
+      KEYS = {
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_multiplex" => "analyze_multiplex.graphql",
+        "analyze_query" => "analyze_query.graphql",
+        "execute_query" => "execute_query.graphql",
+        "execute_query_lazy" => "execute_query_lazy.graphql",
+        "execute_field" => "execute_field.graphql",
+        "execute_field_lazy" => "execute_field_lazy.graphql",
+        "authorized" => "authorized.graphql",
+        "authorized_lazy" => "authorized_lazy.graphql",
+        "resolve_type" => "resolve_type.graphql",
+        "resolve_type_lazy" => "resolve_type.graphql",
+      }
+
+      MAX_KEYS_SIZE = 100
+
+      # Initialize a new NotificationsTracing instance
+      #
+      # @param [Object] notifications_engine The notifications engine to use
+      def initialize(notifications_engine)
+        @notifications_engine = notifications_engine
+      end
+
+      # Sends a GraphQL tracing event to the notification handler
+      #
+      # @example
+      # . notifications_engine = Dry::Monitor::Notifications.new(:graphql)
+      # . tracer = GraphQL::Tracing::NotificationsTracing.new(notifications_engine)
+      # . tracer.trace("lex") { ... }
+      #
+      # @param [string] key The key for the event
+      # @param [Hash] metadata The metadata for the event
+      # @yield The block to execute for the event
+      def trace(key, metadata, &blk)
+        prefixed_key = KEYS[key] || "#{key}.graphql"
+
+        # Cache the new keys while making sure not to induce a memory leak
+        if KEYS.size < MAX_KEYS_SIZE
+          KEYS[key] ||= prefixed_key
+        end
+
+        @notifications_engine.instrument(prefixed_key, metadata, &blk)
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -35,7 +35,8 @@ module GraphQL
           # It's called when you subclass this base connection, trying to use the
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable)
+          # @param field_options [Hash] Any extra keyword arguments to pass to the `field :edges, ...` and `field :nodes, ...` configurations
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -43,13 +44,22 @@ module GraphQL
             @edge_type = edge_type_class
             @edge_class = edge_class
 
-            field :edges, [edge_type_class, null: edge_nullable],
+            base_field_options = {
+              name: :edges,
+              type: [edge_type_class, null: edge_nullable],
               null: edges_nullable,
               description: "A list of edges.",
               legacy_edge_class: edge_class, # This is used by the old runtime only, for EdgesInstrumentation
-              connection: false
+              connection: false,
+            }
 
-            define_nodes_field(node_nullable) if nodes_field
+            if field_options
+              base_field_options.merge!(field_options)
+            end
+
+            field(**base_field_options)
+
+            define_nodes_field(node_nullable, field_options: field_options) if nodes_field
 
             description("The connection type for #{node_type_name}.")
           end
@@ -60,8 +70,8 @@ module GraphQL
           end
 
           # Add the shortcut `nodes` field to this connection and its subclasses
-          def nodes_field(node_nullable: self.node_nullable)
-            define_nodes_field(node_nullable)
+          def nodes_field(node_nullable: self.node_nullable, field_options: nil)
+            define_nodes_field(node_nullable, field_options: field_options)
           end
 
           def authorized?(obj, ctx)
@@ -118,11 +128,18 @@ module GraphQL
 
           private
 
-          def define_nodes_field(nullable)
-            field :nodes, [@node_type, null: nullable],
+          def define_nodes_field(nullable, field_options: nil)
+            base_field_options = {
+              name: :nodes,
+              type: [@node_type, null: nullable],
               null: nullable,
               description: "A list of nodes.",
-              connection: false
+              connection: false,
+            }
+            if field_options
+              base_field_options.merge!(field_options)
+            end
+            field(**base_field_options)
           end
         end
 

data/lib/graphql/types/relay/default_relay.rb

@@ -17,7 +17,11 @@ module GraphQL
         end
 
         def to_graphql
-          type_defn = super
+          type_defn = if method(:to_graphql).super_method.arity
+            super(silence_deprecation_warning: true)
+          else
+            super
+          end
           type_defn.default_relay = default_relay?
           type_defn
         end

data/lib/graphql/types/relay/edge_behaviors.rb

@@ -16,11 +16,22 @@ module GraphQL
           #
           # @param node_type [Class] A `Schema::Object` subclass
           # @param null [Boolean]
-          def node_type(node_type = nil, null: self.node_nullable)
+          # @param field_options [Hash] Any extra arguments to pass to the `field :node` configuration
+          def node_type(node_type = nil, null: self.node_nullable, field_options: nil)
             if node_type
               @node_type = node_type
               # Add a default `node` field
-              field :node, node_type, null: null, description: "The item at the end of the edge.", connection: false
+              base_field_options = {
+                name: :node,
+                type: node_type,
+                null: null,
+                description: "The item at the end of the edge.",
+                connection: false,
+              }
+              if field_options
+                base_field_options.merge!(field_options)
+              end
+              field(**base_field_options)
             end
             @node_type
           end

data/lib/graphql/types/relay/has_node_field.rb

@@ -22,7 +22,7 @@ module GraphQL
 
           def field_block
             Proc.new {
-              argument :id, "ID!", required: true,
+              argument :id, "ID!",
                 description: "ID of the object."
 
               def resolve(obj, args, ctx)

data/lib/graphql/types/relay/has_nodes_field.rb

@@ -22,7 +22,7 @@ module GraphQL
 
           def field_block
             Proc.new {
-              argument :ids, "[ID!]!", required: true,
+              argument :ids, "[ID!]!",
                 description: "IDs of the objects."
 
               def resolve(obj, args, ctx)

data/lib/graphql/types/relay/node_field.rb

@@ -2,8 +2,7 @@
 module GraphQL
   module Types
     module Relay
-      # This can be used for implementing `Query.node(id: ...)`,
-      # or use it for inspiration for your own field definition.
+      # Don't use this field directly, instead, use one of these approaches:
       #
       # @example Adding this field directly
       #   include GraphQL::Types::Relay::HasNodeField
@@ -19,7 +18,19 @@ module GraphQL
       #     context.schema.object_from_id(id, context)
       #   end
       #
-      NodeField = GraphQL::Schema::Field.new(owner: nil, **HasNodeField.field_options, &HasNodeField.field_block)
+      def self.const_missing(const_name)
+        if const_name == :NodeField
+          message = "NodeField is deprecated, use `include GraphQL::Types::Relay::HasNodeField` instead."
+          message += "\n(referenced from #{caller(1, 1).first})"
+          GraphQL::Deprecation.warn(message)
+
+          DeprecatedNodeField
+        else
+          super
+        end
+      end
+
+      DeprecatedNodeField = GraphQL::Schema::Field.new(owner: nil, **HasNodeField.field_options, &HasNodeField.field_block)
     end
   end
 end

data/lib/graphql/types/relay/nodes_field.rb

@@ -2,8 +2,7 @@
 module GraphQL
   module Types
     module Relay
-      # This can be used for implementing `Query.nodes(ids: ...)`,
-      # or use it for inspiration for your own field definition.
+      # Don't use this directly, instead, use one of these:
       #
       # @example Adding this field directly
       #   include GraphQL::Types::Relay::HasNodesField
@@ -21,7 +20,18 @@ module GraphQL
       #     end
       #   end
       #
-      NodesField = GraphQL::Schema::Field.new(owner: nil, **HasNodesField.field_options, &HasNodesField.field_block)
+      def self.const_missing(const_name)
+        if const_name == :NodesField
+          message = "NodesField is deprecated, use `include GraphQL::Types::Relay::HasNodesField` instead."
+          message += "\n(referenced from #{caller(1, 1).first})"
+          GraphQL::Deprecation.warn(message)
+
+          DeprecatedNodesField
+        else
+          super
+        end
+      end
+      DeprecatedNodesField = GraphQL::Schema::Field.new(owner: nil, **HasNodesField.field_options, &HasNodesField.field_block)
     end
   end
 end

data/lib/graphql/version.rb

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