graphql 1.13.0 → 1.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 853fa0482ef0c3bafe04dce77dff9bb685633a1e4c273fd234169f98d595352c
-  data.tar.gz: 6cf800af8dfc469f4d7a375ee22f6d98e03207799f813f10176916f09a0a4064
+  metadata.gz: 4f950da72b7fb585a9135dc893b2c2cf41c8a6482a82a0f7401ba913d48c643f
+  data.tar.gz: 8d5cd615133ca107e38ab18ccc59902c6eaa1f8d7ffeef5c7af474f1e4c5cde9
 SHA512:
-  metadata.gz: 7bcd2b94fa64ab65fb47995a4896b08629bfc9b66f7797dfd4959ad8ccdb5332bf63ae49f5139c7d1766b3d72cb500da257c611e628dc5db36ae26b472c5d51c
-  data.tar.gz: 51a5c6791429c17940d8d0a5407efb852fd4ddbe7a5eaf706dd8fb074a6654f17b32b08f21956e4e450dff6cff05fb0020a7ff8a141fe38f3e09b8433ca1b4ea
+  metadata.gz: 961ac5fe60ef45ea3eed645bcbef7793363dabe18d676c739188430b95e86887470d93966eccdfe89f0bebe99e0c4e5cfa68b5e697865d8228713a080d28f98d
+  data.tar.gz: a545feab4e634fc1039c232c43fe45412382b44215fe4038211e19a9fcef44dd02bb0db22eda2c3f78553867b7c3aed1b7630947a83d72741431e6fe2caeffdf

data/lib/generators/graphql/core.rb

@@ -19,7 +19,9 @@ module Graphql
         sentinel = /< GraphQL::Schema\s*\n/m
 
         in_root do
-          inject_into_file schema_file_path, "  #{type}(Types::#{name})\n", after: sentinel, verbose: false, force: false
+          if File.exist?(schema_file_path)
+            inject_into_file schema_file_path, "  #{type}(Types::#{name})\n", after: sentinel, verbose: false, force: false
+          end
         end
       end
 

data/lib/generators/graphql/install_generator.rb

@@ -122,8 +122,15 @@ module Graphql
         if options.api?
           say("Skipped graphiql, as this rails project is API only")
           say("  You may wish to use GraphiQL.app for development: https://github.com/skevy/graphiql-app")
-        elsif !options[:skip_graphiql] && !File.read(Rails.root.join("Gemfile")).include?("graphiql-rails")
-          gem("graphiql-rails", group: :development)
+        elsif !options[:skip_graphiql]
+          # `gem(...)` uses `gsub_file(...)` under the hood, which is a no-op for `rails destroy...` (when `behavior == :revoke`).
+          # So handle that case by calling `gsub_file` with `force: true`.
+          if behavior == :invoke && !File.read(Rails.root.join("Gemfile")).include?("graphiql-rails")
+            gem("graphiql-rails", group: :development)
+          elsif behavior == :revoke
+            gemfile_pattern = /\n\s*gem ('|")graphiql-rails('|"), :?group(:| =>) :development/
+            gsub_file Rails.root.join("Gemfile"), gemfile_pattern, "", { force: true }
+          end
 
           # This is a little cheat just to get cleaner shell output:
           log :route, 'graphiql-rails'

data/lib/graphql/base_type.rb

@@ -41,7 +41,9 @@ module GraphQL
     alias :graphql_name :name
     # Future-compatible alias
     # @see {GraphQL::SchemaMember}
-    alias :graphql_definition :itself
+    def graphql_definition(silence_deprecation_warning: false)
+      itself
+    end
 
     def type_class
       metadata[:type_class]
@@ -194,7 +196,7 @@ module GraphQL
         resolve_related_type(Object.const_get(type_arg))
       else
         if type_arg.respond_to?(:graphql_definition)
-          type_arg.graphql_definition
+          type_arg.graphql_definition(silence_deprecation_warning: true)
         else
           type_arg
         end

data/lib/graphql/boolean_type.rb

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

data/lib/graphql/directive/deprecated_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition
+GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive/include_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition
+GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive/skip_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition
+GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition(silence_deprecation_warning: true)

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

@@ -870,16 +870,20 @@ module GraphQL
               # but don't wrap the continuation below
               inner_obj = begin
                 query.with_error_handling do
-                  if trace
-                    query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments, ast_node: ast_node}) do
+                  begin
+                    if trace
+                      query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments, ast_node: ast_node}) do
+                        schema.sync_lazy(lazy_obj)
+                      end
+                    else
                       schema.sync_lazy(lazy_obj)
                     end
-                  else
-                    schema.sync_lazy(lazy_obj)
+                  rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
+                    err
                   end
                 end
-                rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
-                  err
+              rescue GraphQL::ExecutionError => ex_err
+                ex_err
               end
               yield(inner_obj)
             end

data/lib/graphql/execution/multiplex.rb

@@ -151,6 +151,9 @@ module GraphQL
 
             result
           end
+          if query.context.namespace?(:__query_result_extensions__)
+            query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
+          end
         end
 
         # use the old `query_execution_strategy` etc to run this query

data/lib/graphql/float_type.rb

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

data/lib/graphql/id_type.rb

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

data/lib/graphql/int_type.rb

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

data/lib/graphql/language/block_string.rb

@@ -7,7 +7,7 @@ module GraphQL
       def self.trim_whitespace(str)
         # Early return for the most common cases:
         if str == ""
-          return ""
+          return "".dup
         elsif !(has_newline = str.include?("\n")) && !(str.start_with?(" "))
           return str
         end
@@ -55,7 +55,7 @@ module GraphQL
         end
 
         # Rebuild the string
-        lines.size > 1 ? lines.join("\n") : (lines.first || "")
+        lines.size > 1 ? lines.join("\n") : (lines.first || "".dup)
       end
 
       def self.print(str, indent: '')

data/lib/graphql/language/nodes.rb

@@ -197,7 +197,16 @@ module GraphQL
               else
                 module_eval <<-RUBY, __FILE__, __LINE__
                   def children
-                    @children ||= (#{children_of_type.keys.map { |k| "@#{k}" }.join(" + ")}).freeze
+                    @children ||= begin
+                      if #{children_of_type.keys.map { |k| "@#{k}.any?" }.join(" || ")}
+                        new_children = []
+                        #{children_of_type.keys.map { |k| "new_children.concat(@#{k})" }.join("; ")}
+                        new_children.freeze
+                        new_children
+                      else
+                        NO_CHILDREN
+                      end
+                    end
                   end
                 RUBY
               end

data/lib/graphql/query/context.rb

@@ -156,6 +156,11 @@ module GraphQL
         @scoped_context = {}
       end
 
+      # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
+      def response_extensions
+        namespace(:__query_result_extensions__)
+      end
+
       def dataloader
         @dataloader ||= self[:dataloader] || (query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new)
       end
@@ -236,6 +241,11 @@ module GraphQL
         @storage[ns]
       end
 
+      # @return [Boolean] true if this namespace was accessed before
+      def namespace?(ns)
+        @storage.key?(ns)
+      end
+
       def inspect
         "#<Query::Context ...>"
       end

data/lib/graphql/relay/global_id_resolve.rb

@@ -10,7 +10,7 @@ module GraphQL
         if obj.is_a?(GraphQL::Schema::Object)
           obj = obj.object
         end
-        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition : @type
+        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition(silence_deprecation_warning: true) : @type
         ctx.query.schema.id_from_object(obj, type, ctx)
       end
     end

data/lib/graphql/relay/page_info.rb

@@ -2,6 +2,6 @@
 module GraphQL
   module Relay
     # Wrap a Connection and expose its page info
-    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition
+    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition(silence_deprecation_warning: true)
   end
 end

data/lib/graphql/schema/argument.rb

@@ -161,6 +161,8 @@ module GraphQL
         true
       end
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
         argument = GraphQL::Argument.new
         argument.name = @name

data/lib/graphql/schema/directive.rb

@@ -8,6 +8,8 @@ module GraphQL
     # - {.resolve}: Wraps field resolution (so it should call `yield` to continue)
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
       class << self
         # Directives aren't types, they don't have kinds.
         undef_method :kind
@@ -53,6 +55,8 @@ module GraphQL
           default_directive
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           defn = GraphQL::Directive.new
           defn.name = self.graphql_name
@@ -62,7 +66,7 @@ module GraphQL
           defn.ast_node = ast_node
           defn.metadata[:type_class] = self
           all_argument_definitions.each do |arg_defn|
-            arg_graphql = arg_defn.to_graphql
+            arg_graphql = arg_defn.to_graphql(silence_deprecation_warning: true)
             defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           # Make a reference to a classic-style Arguments class

data/lib/graphql/schema/enum.rb

@@ -108,6 +108,8 @@ module GraphQL
           enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         # @return [GraphQL::EnumType]
         def to_graphql
           enum_type = GraphQL::EnumType.new
@@ -116,7 +118,7 @@ module GraphQL
           enum_type.introspection = introspection
           enum_type.ast_node = ast_node
           values.each do |name, val|
-            enum_type.add_value(val.to_graphql)
+            enum_type.add_value(val.deprecated_to_graphql)
           end
           enum_type.metadata[:type_class] = self
           enum_type

data/lib/graphql/schema/enum_value.rb

@@ -73,6 +73,8 @@ module GraphQL
         @value
       end
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       # @return [GraphQL::EnumType::EnumValue] A runtime-ready object derived from this object
       def to_graphql
         enum_value = GraphQL::EnumType::EnumValue.new

data/lib/graphql/schema/field.rb

@@ -290,6 +290,7 @@ module GraphQL
         @subscription_scope = subscription_scope
 
         @extensions = EMPTY_ARRAY
+        @call_after_define = false
         # This should run before connection extension,
         # but should it run after the definition block?
         if scoped?
@@ -322,6 +323,9 @@ module GraphQL
             instance_eval(&definition_block)
           end
         end
+
+        self.extensions.each(&:after_define_apply)
+        @call_after_define = true
       end
 
       # If true, subscription updates with this field can be shared between viewers
@@ -354,27 +358,20 @@ module GraphQL
       # @example adding an extension with options
       #   extensions([MyExtensionClass, { AnotherExtensionClass => { filter: true } }])
       #
-      # @param extensions [Array<Class, Hash<Class => Object>>] Add extensions to this field. For hash elements, only the first key/value is used.
+      # @param extensions [Array<Class, Hash<Class => Hash>>] Add extensions to this field. For hash elements, only the first key/value is used.
       # @return [Array<GraphQL::Schema::FieldExtension>] extensions to apply to this field
       def extensions(new_extensions = nil)
-        if new_extensions.nil?
-          # Read the value
-          @extensions
-        else
-          if @extensions.frozen?
-            @extensions = @extensions.dup
-          end
-          new_extensions.each do |extension|
-            if extension.is_a?(Hash)
-              extension = extension.to_a[0]
-              extension_class, options = *extension
-              @extensions << extension_class.new(field: self, options: options)
+        if new_extensions
+          new_extensions.each do |extension_config|
+            if extension_config.is_a?(Hash)
+              extension_class, options = *extension_config.to_a[0]
+              self.extension(extension_class, options)
             else
-              extension_class = extension
-              @extensions << extension_class.new(field: self, options: nil)
+              self.extension(extension_config)
             end
           end
         end
+        @extensions
       end
 
       # Add `extension` to this field, initialized with `options` if provided.
@@ -385,10 +382,19 @@ module GraphQL
       # @example adding an extension with options
       #   extension(MyExtensionClass, filter: true)
       #
-      # @param extension [Class] subclass of {Schema::Fieldextension}
-      # @param options [Object] if provided, given as `options:` when initializing `extension`.
-      def extension(extension, options = nil)
-        extensions([{extension => options}])
+      # @param extension_class [Class] subclass of {Schema::FieldExtension}
+      # @param options [Hash] if provided, given as `options:` when initializing `extension`.
+      # @return [void]
+      def extension(extension_class, options = nil)
+        extension_inst = extension_class.new(field: self, options: options)
+        if @extensions.frozen?
+          @extensions = @extensions.dup
+        end
+        if @call_after_define
+          extension_inst.after_define_apply
+        end
+        @extensions << extension_inst
+        nil
       end
 
       # Read extras (as symbols) from this field,
@@ -441,10 +447,15 @@ module GraphQL
             if lookahead.selects?(:total) || lookahead.selects?(:total_count) || lookahead.selects?(:count)
               metadata_complexity += 1
             end
+
+            nodes_edges_complexity = 0
+            nodes_edges_complexity += 1 if lookahead.selects?(:edges)
+            nodes_edges_complexity += 1 if lookahead.selects?(:nodes)
+
             # Possible bug: selections on `edges` and `nodes` are _both_ multiplied here. Should they be?
-            items_complexity = child_complexity - metadata_complexity
+            items_complexity = child_complexity - metadata_complexity - nodes_edges_complexity
             # Add 1 for _this_ field
-            1 + (max_possible_page_size * items_complexity) + metadata_complexity
+            1 + (max_possible_page_size * items_complexity) + metadata_complexity + nodes_edges_complexity
           end
         else
           defined_complexity = complexity
@@ -488,6 +499,8 @@ module GraphQL
       # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
       attr_reader :max_page_size
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       # @return [GraphQL::Field]
       def to_graphql
         field_defn = if @field
@@ -543,7 +556,7 @@ module GraphQL
         field_defn.ast_node = ast_node
 
         all_argument_definitions.each do |defn|
-          arg_graphql = defn.to_graphql
+          arg_graphql = defn.deprecated_to_graphql
           field_defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
         end
 
@@ -604,10 +617,13 @@ module GraphQL
       end
 
       def authorized?(object, args, context)
-        if @resolver_class
-          # The resolver will check itself during `resolve()`
+        resolver_authed = if @resolver_class
+          # The resolver _instance_ will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
+          true
+        end
+        resolver_authed && begin
           if (arg_values = context[:current_arguments])
             # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
             using_arg_values = true

data/lib/graphql/schema/field_extension.rb

@@ -15,15 +15,40 @@ module GraphQL
       # @return [Object]
       attr_reader :options
 
+      # @return [Array<Symbol>, nil] `default_argument`s added, if any were added (otherwise, `nil`)
+      attr_reader :added_default_arguments
+
       # Called when the extension is mounted with `extension(name, options)`.
-      # The instance is frozen to avoid improper use of state during execution.
+      # The instance will be frozen to avoid improper use of state during execution.
       # @param field [GraphQL::Schema::Field] The field where this extension was mounted
       # @param options [Object] The second argument to `extension`, or `{}` if nothing was passed.
       def initialize(field:, options:)
         @field = field
         @options = options || {}
+        @added_default_arguments = nil
         apply
-        freeze
+      end
+
+      class << self
+        # @return [Array(Array, Hash), nil] A list of default argument configs, or `nil` if there aren't any
+        def default_argument_configurations
+          args = superclass.respond_to?(:default_argument_configurations) ? superclass.default_argument_configurations : nil
+          if @own_default_argument_configurations
+            if args
+              args.concat(@own_default_argument_configurations)
+            else
+              args = @own_default_argument_configurations.dup
+            end
+          end
+          args
+        end
+
+        # @see Argument#initialize
+        # @see HasArguments#argument
+        def default_argument(*argument_args, **argument_kwargs)
+          configs = @own_default_argument_configurations ||= []
+          configs << [argument_args, argument_kwargs]
+        end
       end
 
       # Called when this extension is attached to a field.
@@ -32,6 +57,31 @@ module GraphQL
       def apply
       end
 
+      # Called after the field's definition block has been executed.
+      # (Any arguments from the block are present on `field`)
+      # @return [void]
+      def after_define
+      end
+
+      # @api private
+      def after_define_apply
+        after_define
+        if (configs = self.class.default_argument_configurations)
+          existing_keywords = field.all_argument_definitions.map(&:keyword)
+          existing_keywords.uniq!
+          @added_default_arguments = []
+          configs.each do |config|
+            argument_args, argument_kwargs = config
+            arg_name = argument_args[0]
+            if !existing_keywords.include?(arg_name)
+              @added_default_arguments << arg_name
+              field.argument(*argument_args, **argument_kwargs)
+            end
+          end
+        end
+        freeze
+      end
+
       # Called before resolving {#field}. It should either:
       #
       # - `yield` values to continue execution; OR

data/lib/graphql/schema/input_object.rb

@@ -132,6 +132,8 @@ module GraphQL
           argument_defn
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::InputObjectType.new
           type_defn.name = graphql_name
@@ -140,7 +142,7 @@ module GraphQL
           type_defn.mutation = mutation
           type_defn.ast_node = ast_node
           all_argument_definitions.each do |arg|
-            type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+            type_defn.arguments[arg.graphql_definition(silence_deprecation_warning: true).name] = arg.graphql_definition(silence_deprecation_warning: true) # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           # Make a reference to a classic-style Arguments class
           self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)

data/lib/graphql/schema/interface.rb

@@ -100,6 +100,8 @@ module GraphQL
           end
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::InterfaceType.new
           type_defn.name = graphql_name
@@ -108,7 +110,7 @@ module GraphQL
           type_defn.type_membership_class = self.type_membership_class
           type_defn.ast_node = ast_node
           fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.graphql_definition
+            field_defn = field_inst.graphql_definition(silence_deprecation_warning: true)
             type_defn.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           type_defn.metadata[:type_class] = self

data/lib/graphql/schema/introspection_system.rb

@@ -107,7 +107,7 @@ module GraphQL
           dup_type_class(const)
         else
           # Use `.to_graphql` to get a freshly-made version, not shared between schemas
-          const.to_graphql
+          const.deprecated_to_graphql
         end
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared

data/lib/graphql/schema/list.rb

@@ -8,8 +8,10 @@ module GraphQL
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
-        @of_type.graphql_definition.to_list_type
+        @of_type.graphql_definition(silence_deprecation_warning: true).to_list_type
       end
 
       # @return [GraphQL::TypeKinds::LIST]

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

@@ -123,8 +123,13 @@ module GraphQL
         end
 
         module ToGraphQLExtension
-          def to_graphql
-            defn = super
+          def to_graphql(*args, **kwargs)
+
+            defn = if args.empty? && kwargs.empty?
+              super()
+            else
+              super
+            end
             accepts_definition_methods.each do |method_name|
               value = public_send(method_name)
               if !value.nil?

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

@@ -11,8 +11,24 @@ module GraphQL
         # A cached result of {.to_graphql}.
         # It's cached here so that user-overridden {.to_graphql} implementations
         # are also cached
-        def graphql_definition
-          @graphql_definition ||= to_graphql
+        def graphql_definition(silence_deprecation_warning: false)
+          @graphql_definition ||= begin
+            unless silence_deprecation_warning
+              message = "Legacy `.graphql_definition` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.graphql_definition` to use a class-based definition instead."
+              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
+              GraphQL::Deprecation.warn(message + caller_message)
+            end
+            deprecated_to_graphql
+          end
+        end
+
+        def deprecated_to_graphql
+          case method(:to_graphql).arity
+          when 0
+            to_graphql
+          else
+            to_graphql(silence_deprecation_warning: true)
+          end
         end
 
         # This is for a common interface with .define-based types
@@ -25,6 +41,17 @@ module GraphQL
           super
           @graphql_definition = nil
         end
+
+        module DeprecatedToGraphQL
+          def to_graphql(silence_deprecation_warning: false)
+            unless silence_deprecation_warning
+              message = "Legacy `.to_graphql` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.to_graphql` to use a class-based definition instead."
+              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
+              GraphQL::Deprecation.warn(message + caller_message)
+            end
+            super()
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/non_null.rb

@@ -8,8 +8,10 @@ module GraphQL
     class NonNull < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
-        @of_type.graphql_definition.to_non_null_type
+        @of_type.graphql_definition(silence_deprecation_warning: true).to_non_null_type
       end
 
        # @return [GraphQL::TypeKinds::NON_NULL]

data/lib/graphql/schema/object.rb

@@ -122,6 +122,8 @@ module GraphQL
           all_fields
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         # @return [GraphQL::ObjectType]
         def to_graphql
           obj_type = GraphQL::ObjectType.new
@@ -132,7 +134,7 @@ module GraphQL
           obj_type.mutation = mutation
           obj_type.ast_node = ast_node
           fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.to_graphql
+            field_defn = field_inst.to_graphql(silence_deprecation_warning: true)
             obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
 

data/lib/graphql/schema/scalar.rb

@@ -14,6 +14,8 @@ module GraphQL
           val
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::ScalarType.new
           type_defn.name = graphql_name

data/lib/graphql/schema/traversal.rb

@@ -173,7 +173,7 @@ Some late-bound types couldn't be resolved:
           end
         when Class
           if member.respond_to?(:graphql_definition)
-            graphql_member = member.graphql_definition
+            graphql_member = member.graphql_definition(silence_deprecation_warning: true)
             visit(schema, graphql_member, context_description)
           else
             raise GraphQL::Schema::InvalidTypeError.new("Unexpected traversal member: #{member} (#{member.class.name})")

data/lib/graphql/schema/union.rb

@@ -33,6 +33,8 @@ module GraphQL
           type_memberships.map(&:object_type)
         end
 
+        prepend GraphQL::Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name

data/lib/graphql/schema/validator.rb

@@ -48,16 +48,13 @@ module GraphQL
           EMPTY_ARRAY
         else
           validates_hash = validates_hash.dup
-          allow_null = validates_hash.delete(:allow_null)
-          allow_blank = validates_hash.delete(:allow_blank)
 
-          # This could be {...}.compact on Ruby 2.4+
           default_options = {}
-          if !allow_null.nil?
-            default_options[:allow_null] = allow_null
+          if validates_hash[:allow_null]
+            default_options[:allow_null] = validates_hash.delete(:allow_null)
           end
-          if !allow_blank.nil?
-            default_options[:allow_blank] = allow_blank
+          if validates_hash[:allow_blank]
+            default_options[:allow_blank] = validates_hash.delete(:allow_blank)
           end
 
           # allow_nil or allow_blank are the _only_ validations:

data/lib/graphql/schema.rb

@@ -845,7 +845,7 @@ module GraphQL
       # - Cause the Schema instance to be created, if it hasn't been created yet
       # - Delegate to that instance
       # Eventually, the methods will be moved into this class, removing the need for the singleton.
-      def_delegators :graphql_definition,
+      def_delegators :deprecated_graphql_definition,
         # Execution
         :execution_strategy_for_operation,
         # Configuration
@@ -854,6 +854,10 @@ module GraphQL
         :id_from_object=, :object_from_id=,
         :remove_handler
 
+      def deprecated_graphql_definition
+        graphql_definition(silence_deprecation_warning: true)
+      end
+
       # @return [GraphQL::Subscriptions]
       attr_accessor :subscriptions
 
@@ -896,8 +900,15 @@ module GraphQL
         @find_cache[path] ||= @finder.find(path)
       end
 
-      def graphql_definition
-        @graphql_definition ||= to_graphql
+      def graphql_definition(silence_deprecation_warning: false)
+        @graphql_definition ||= begin
+          unless silence_deprecation_warning
+            message = "Legacy `.graphql_definition` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Use a class-based definition instead."
+            caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
+            GraphQL::Deprecation.warn(message + caller_message)
+          end
+          to_graphql(silence_deprecation_warning: silence_deprecation_warning)
+        end
       end
 
       def default_filter
@@ -929,19 +940,20 @@ module GraphQL
         find_inherited_value(:plugins, EMPTY_ARRAY) + own_plugins
       end
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
       def to_graphql
         schema_defn = self.new
         schema_defn.raise_definition_error = true
-        schema_defn.query = query && query.graphql_definition
-        schema_defn.mutation = mutation && mutation.graphql_definition
-        schema_defn.subscription = subscription && subscription.graphql_definition
+        schema_defn.query = query && query.graphql_definition(silence_deprecation_warning: true)
+        schema_defn.mutation = mutation && mutation.graphql_definition(silence_deprecation_warning: true)
+        schema_defn.subscription = subscription && subscription.graphql_definition(silence_deprecation_warning: true)
         schema_defn.validate_timeout = validate_timeout
         schema_defn.validate_max_errors = validate_max_errors
         schema_defn.max_complexity = max_complexity
         schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
         schema_defn.default_max_page_size = default_max_page_size
-        schema_defn.orphan_types = orphan_types.map(&:graphql_definition)
+        schema_defn.orphan_types = orphan_types.map { |t| t.graphql_definition(silence_deprecation_warning: true) }
         schema_defn.disable_introspection_entry_points = disable_introspection_entry_points?
         schema_defn.disable_schema_introspection_entry_point = disable_schema_introspection_entry_point?
         schema_defn.disable_type_introspection_entry_point = disable_type_introspection_entry_point?

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

@@ -50,15 +50,15 @@ module GraphQL
         @arg_conflicts = nil
 
         yield
-
-        field_conflicts.each_value { |error| add_error(error) }
-        arg_conflicts.each_value { |error| add_error(error) }
+        # don't initialize these if they weren't initialized in the block:
+        @field_conflicts && @field_conflicts.each_value { |error| add_error(error) }
+        @arg_conflicts && @arg_conflicts.each_value { |error| add_error(error) }
       end
 
       def conflicts_within_selection_set(node, parent_type)
         return if parent_type.nil?
 
-        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: [])
+        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: nil)
 
         # (A) Find find all conflicts "within" the fields of this selection set.
         find_conflicts_within(fields)
@@ -198,10 +198,14 @@ module GraphQL
         response_keys.each do |key, fields|
           next if fields.size < 2
           # find conflicts within nodes
-          for i in 0..fields.size - 1
-            for j in i + 1..fields.size - 1
+          i = 0
+          while i < fields.size
+            j = i + 1
+            while j < fields.size
               find_conflict(key, fields[i], fields[j])
+              j += 1
             end
+            i += 1
           end
         end
       end
@@ -243,7 +247,9 @@ module GraphQL
       end
 
       def find_conflicts_between_sub_selection_sets(field1, field2, mutually_exclusive:)
-        return if field1.definition.nil? || field2.definition.nil?
+        return if field1.definition.nil? ||
+          field2.definition.nil? ||
+          (field1.node.selections.empty? && field2.node.selections.empty?)
 
         return_type1 = field1.definition.type.unwrap
         return_type2 = field2.definition.type.unwrap
@@ -323,6 +329,7 @@ module GraphQL
         if node.selections.empty?
           NO_SELECTIONS
         else
+          parents ||= []
           fields, fragment_spreads = find_fields_and_fragments(node.selections, owner_type: owner_type, parents: parents, fields: [], fragment_spreads: [])
           response_keys = fields.group_by { |f| f.node.alias || f.node.name }
           [response_keys, fragment_spreads]

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

@@ -16,6 +16,8 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
+        args = defn.arguments(context.query.context)
+        return if args.empty?
         present_argument_names = ast_node.arguments.map(&:name)
         required_argument_names = context.warden.arguments(defn)
           .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }

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

@@ -216,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/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/version.rb

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

data/lib/graphql.rb

@@ -107,6 +107,7 @@ require "graphql/internal_representation"
 require "graphql/directive"
 require "graphql/static_validation"
 require "graphql/execution"
+require "graphql/deprecation"
 require "graphql/boolean_type"
 require "graphql/float_type"
 require "graphql/id_type"
@@ -130,7 +131,6 @@ require "graphql/authorization"
 require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
-require "graphql/deprecation"
 require "graphql/directive/include_directive"
 require "graphql/directive/skip_directive"
 require "graphql/directive/deprecated_directive"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.13.0
+  version: 1.13.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-24 00:00:00.000000000 Z
+date: 2021-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips