graphql 1.13.0 → 1.13.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 853fa0482ef0c3bafe04dce77dff9bb685633a1e4c273fd234169f98d595352c
-  data.tar.gz: 6cf800af8dfc469f4d7a375ee22f6d98e03207799f813f10176916f09a0a4064
+  metadata.gz: 51f1e91399e97a5376028af68f7f9c0f01b2d7ff8f342ada08eb984302ea56c3
+  data.tar.gz: eb2a62700254c18263f19ae05027f64b725df4bbb100e2c251652a16cfab6afb
 SHA512:
-  metadata.gz: 7bcd2b94fa64ab65fb47995a4896b08629bfc9b66f7797dfd4959ad8ccdb5332bf63ae49f5139c7d1766b3d72cb500da257c611e628dc5db36ae26b472c5d51c
-  data.tar.gz: 51a5c6791429c17940d8d0a5407efb852fd4ddbe7a5eaf706dd8fb074a6654f17b32b08f21956e4e450dff6cff05fb0020a7ff8a141fe38f3e09b8433ca1b4ea
+  metadata.gz: 861c8880bf96831e4072f51bcb8dc5e6302040b88ffd7d94cea2288ef281bd317a2235fe98b10ca10687c2f616ac6a740729149ecd44ab4cef2779a9838e7c42
+  data.tar.gz: 985e2119a77f367503b133ce37108a7bedaf99c21c6edb6f6eb1b25d2be80954233f9344afb52f19ffbfca864844b180f11b07b09baf58462066b4c1794c830e

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/analysis/ast/field_usage.rb

@@ -15,8 +15,12 @@ module GraphQL
           field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
-
-          extract_deprecated_arguments(visitor.query.arguments_for(node, visitor.field_definition).argument_values)
+          arguments = visitor.query.arguments_for(node, visitor.field_definition)
+          # If there was an error when preparing this argument object,
+          # then this might be an error or something:
+          if arguments.respond_to?(:argument_values)
+            extract_deprecated_arguments(arguments.argument_values)
+          end
         end
 
         def result

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

@@ -516,7 +516,7 @@ module GraphQL
               after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
                 if HALT != continue_value
-                  continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments, result_name, selection_result)
+                  continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result)
                 end
               end
             end
@@ -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/document_from_schema_definition.rb

@@ -196,10 +196,14 @@ module GraphQL
         when "INPUT_OBJECT"
           GraphQL::Language::Nodes::InputObject.new(
             arguments: default_value.to_h.map do |arg_name, arg_value|
-              arg_type = @warden.arguments(type).find { |a| a.graphql_name == arg_name.to_s }.type
+              args = @warden.arguments(type)
+              arg = args.find { |a| a.keyword.to_s == arg_name.to_s }
+              if arg.nil?
+                raise ArgumentError, "No argument definition on #{type.graphql_name} for argument: #{arg_name.inspect} (expected one of: #{args.map(&:keyword)})"
+              end
               GraphQL::Language::Nodes::Argument.new(
-                name: arg_name.to_s,
-                value: build_default_value(arg_value, arg_type)
+                name: arg.graphql_name.to_s,
+                value: build_default_value(arg_value, arg.type)
               )
             end
           )

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
@@ -332,7 +341,7 @@ module GraphQL
       #    end
       #  end
       #
-      #  document.to_query_string(printer: VariableSrubber.new)
+      #  document.to_query_string(printer: VariableScrubber.new)
       #
       class Document < AbstractNode
         scalar_methods false

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -7,13 +7,18 @@ module GraphQL
     class ActiveRecordRelationConnection < Pagination::RelationConnection
       private
 
-      def relation_larger_than(relation, size)
-        initial_offset = relation.offset_value || 0
-        relation.offset(initial_offset + size).exists?
+      def relation_larger_than(relation, initial_offset, size)
+        if already_loaded?(relation)
+          (relation.size + initial_offset) > size
+        else
+          set_offset(sliced_nodes, initial_offset + size).exists?
+        end
       end
 
       def relation_count(relation)
-        int_or_hash = if relation.respond_to?(:unscope)
+        int_or_hash = if already_loaded?(relation)
+          relation.size
+        elsif relation.respond_to?(:unscope)
           relation.unscope(:order).count(:all)
         else
           # Rails 3
@@ -28,11 +33,19 @@ module GraphQL
       end
 
       def relation_limit(relation)
-        relation.limit_value
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.limit_value
+        end
       end
 
       def relation_offset(relation)
-        relation.offset_value
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.offset_value
+        end
       end
 
       def null_relation(relation)
@@ -43,6 +56,30 @@ module GraphQL
           relation.where("1=2")
         end
       end
+
+      def set_limit(nodes, limit)
+        if already_loaded?(nodes)
+          nodes.take(limit)
+        else
+          super
+        end
+      end
+
+      def set_offset(nodes, offset)
+        if already_loaded?(nodes)
+          # If the client sent a bogus cursor beyond the size of the relation,
+          # it might get `nil` from `#[...]`, so return an empty array in that case
+          nodes[offset..-1] || []
+        else
+          super
+        end
+      end
+
+      private
+
+      def already_loaded?(relation)
+        relation.is_a?(Array) || relation.loaded?
+      end
     end
   end
 end

data/lib/graphql/pagination/relation_connection.rb

@@ -35,7 +35,7 @@ module GraphQL
             if @nodes && @nodes.count < first
               false
             else
-              relation_larger_than(sliced_nodes, first)
+              relation_larger_than(sliced_nodes, @sliced_nodes_offset, first)
             end
           else
             false
@@ -54,9 +54,10 @@ module GraphQL
       private
 
       # @param relation [Object] A database query object
+      # @param _initial_offset [Integer] The number of items already excluded from the relation
       # @param size [Integer] The value against which we check the relation size
       # @return [Boolean] True if the number of items in this relation is larger than `size`
-      def relation_larger_than(relation, size)
+      def relation_larger_than(relation, _initial_offset, size)
         relation_count(set_limit(relation, size + 1)) == size + 1
       end
 
@@ -111,30 +112,51 @@ module GraphQL
         end
       end
 
-      # Apply `before` and `after` to the underlying `items`,
-      # returning a new relation.
-      def sliced_nodes
-        @sliced_nodes ||= begin
-          paginated_nodes = items
-
+      def calculate_sliced_nodes_parameters
+        if defined?(@sliced_nodes_limit)
+          return
+        else
           if after_offset
             previous_offset = relation_offset(items) || 0
-            paginated_nodes = set_offset(paginated_nodes, previous_offset + after_offset)
+            relation_offset = previous_offset + after_offset
           end
 
           if before_offset && after_offset
             if after_offset < before_offset
               # Get the number of items between the two cursors
               space_between = before_offset - after_offset - 1
-              paginated_nodes = set_limit(paginated_nodes, space_between)
+              relation_limit = space_between
             else
-              # TODO I think this is untested
               # The cursors overextend one another to an empty set
-              paginated_nodes = null_relation(paginated_nodes)
+              @sliced_nodes_null_relation = true
             end
           elsif before_offset
             # Use limit to cut off the tail of the relation
-            paginated_nodes = set_limit(paginated_nodes, before_offset - 1)
+            relation_limit = before_offset - 1
+          end
+
+          @sliced_nodes_limit = relation_limit
+          @sliced_nodes_offset = relation_offset || 0
+        end
+      end
+
+      # Apply `before` and `after` to the underlying `items`,
+      # returning a new relation.
+      def sliced_nodes
+        @sliced_nodes ||= begin
+          calculate_sliced_nodes_parameters
+          paginated_nodes = items
+
+          if @sliced_nodes_null_relation
+            paginated_nodes = null_relation(paginated_nodes)
+          else
+            if @sliced_nodes_limit
+              paginated_nodes = set_limit(paginated_nodes, @sliced_nodes_limit)
+            end
+
+            if @sliced_nodes_offset
+              paginated_nodes = set_offset(paginated_nodes, @sliced_nodes_offset)
+            end
           end
 
           paginated_nodes
@@ -155,32 +177,40 @@ module GraphQL
       # returning a new relation
       def limited_nodes
         @limited_nodes ||= begin
-          paginated_nodes = sliced_nodes
-          previous_limit = relation_limit(paginated_nodes)
+          calculate_sliced_nodes_parameters
+          if @sliced_nodes_null_relation
+            # it's an empty set
+            return sliced_nodes
+          end
+          relation_limit = @sliced_nodes_limit
+          relation_offset = @sliced_nodes_offset
 
-          if first && (previous_limit.nil? || previous_limit > first)
+          if first && (relation_limit.nil? || relation_limit > first)
             # `first` would create a stricter limit that the one already applied, so add it
-            paginated_nodes = set_limit(paginated_nodes, first)
+            relation_limit = first
           end
 
           if last
-            if (lv = relation_limit(paginated_nodes))
-              if last <= lv
+            if relation_limit
+              if last <= relation_limit
                 # `last` is a smaller slice than the current limit, so apply it
-                offset = (relation_offset(paginated_nodes) || 0) + (lv - last)
-                paginated_nodes = set_offset(paginated_nodes, offset)
-                paginated_nodes = set_limit(paginated_nodes, last)
+                relation_offset += (relation_limit - last)
+                relation_limit = last
               end
             else
               # No limit, so get the last items
-              sliced_nodes_count = relation_count(@sliced_nodes)
-              offset = (relation_offset(paginated_nodes) || 0) + sliced_nodes_count - [last, sliced_nodes_count].min
-              paginated_nodes = set_offset(paginated_nodes, offset)
-              paginated_nodes = set_limit(paginated_nodes, last)
+              sliced_nodes_count = relation_count(sliced_nodes)
+              relation_offset += (sliced_nodes_count - [last, sliced_nodes_count].min)
+              relation_limit = last
             end
           end
 
-          @paged_nodes_offset = relation_offset(paginated_nodes)
+          @paged_nodes_offset = relation_offset
+          paginated_nodes = items
+          paginated_nodes = set_offset(paginated_nodes, relation_offset)
+          if relation_limit
+            paginated_nodes = set_limit(paginated_nodes, relation_limit)
+          end
           paginated_nodes
         end
       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

@@ -37,7 +37,7 @@ module GraphQL
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
-      # @param required [Boolean] if true, this argument is non-null; if false, this argument is nullable
+      # @param required [Boolean, :nullable] if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
       # @param description [String]
       # @param default_value [Object]
       # @param as [Symbol] Override the keyword name when passed to a method
@@ -53,7 +53,7 @@ module GraphQL
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
-        @null = !required
+        @null = required != true
         @default_value = default_value
         @owner = owner
         @as = as
@@ -72,6 +72,9 @@ module GraphQL
         end
 
         self.validates(validates)
+        if required == :nullable
+          self.owner.validates(required: { argument: arg_name })
+        end
 
         if definition_block
           if definition_block.arity == 1
@@ -147,20 +150,15 @@ module GraphQL
             end
           end
         elsif as_type.kind.input_object?
-          as_type.arguments(ctx).each do |_name, input_obj_arg|
-            input_obj_arg = input_obj_arg.type_class
-            # TODO: this skips input objects whose values were alread replaced with application objects.
-            # See: https://github.com/rmosolgo/graphql-ruby/issues/2633
-            if value.is_a?(InputObject) && value.key?(input_obj_arg.keyword) && !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
-              return false
-            end
-          end
+          return as_type.authorized?(obj, value, ctx)
         end
         # None of the early-return conditions were activated,
         # so this is authorized.
         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