graphql 1.12.24 → 1.13.19

data/lib/generators/graphql/type_generator.rb

@@ -8,14 +8,28 @@ require_relative 'core'
 
 module Graphql
   module Generators
-    class TypeGeneratorBase < Rails::Generators::Base
+    class TypeGeneratorBase < Rails::Generators::NamedBase
       include Core
 
-      argument :type_name,
-        type: :string,
-        required: true,
-        banner: "TypeName",
-        desc: "Name of this object type (expressed as Ruby or GraphQL)"
+      class_option 'namespaced_types',
+        type: :boolean,
+        required: false,
+        default: false,
+        banner: "Namespaced",
+        desc: "If the generated types will be namespaced"
+
+      argument :custom_fields,
+                type: :array,
+                default: [],
+                banner: "name:type name:type ...",
+                desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+
+      
+      attr_accessor :graphql_type
+
+      def create_type_file
+        template "#{graphql_type}.erb", "#{options[:directory]}/types#{subdirectory}/#{type_file_name}.rb"
+      end
 
       # Take a type expression in any combination of GraphQL or Ruby styles
       # and return it in a specified output style
@@ -61,12 +75,12 @@ module Graphql
 
       # @return [String] The user-provided type name, normalized to Ruby code
       def type_ruby_name
-        @type_ruby_name ||= self.class.normalize_type_expression(type_name, mode: :ruby)[0]
+        @type_ruby_name ||= self.class.normalize_type_expression(name, mode: :ruby)[0]
       end
 
       # @return [String] The user-provided type name, as a GraphQL name
       def type_graphql_name
-        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
+        @type_graphql_name ||= self.class.normalize_type_expression(name, mode: :graphql)[0]
       end
 
       # @return [String] The user-provided type name, as a file name (without extension)
@@ -83,6 +97,24 @@ module Graphql
         }
       end
 
+      def ruby_class_name
+        class_prefix = 
+          if options[:namespaced_types]
+            "#{graphql_type.pluralize.camelize}::"
+          else
+            ""
+          end
+        @ruby_class_name || class_prefix + type_ruby_name.sub(/^Types::/, "")
+      end
+
+      def subdirectory
+        if options[:namespaced_types]
+          "/#{graphql_type.pluralize}"
+        else
+          ""
+        end
+      end
+
       class NormalizedField
         def initialize(name, type_expr, null)
           @name = name
@@ -90,8 +122,12 @@ module Graphql
           @null = null
         end
 
-        def to_ruby
-          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        def to_object_field
+          "field :#{@name}, #{@type_expr}#{@null ? '' : ', null: false'}"
+        end
+
+        def to_input_argument
+          "argument :#{@name}, #{@type_expr}, required: false"
         end
       end
     end

data/lib/generators/graphql/union_generator.rb

@@ -19,14 +19,14 @@ module Graphql
         banner: "type type ...",
         desc: "Possible types for this union (expressed as Ruby or GraphQL)"
 
-      def create_type_file
-        template "union.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
-      end
-
       private
 
+      def graphql_type
+        "union"
+      end
+
       def normalized_possible_types
-        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
+        custom_fields.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
       end
     end
   end

data/lib/graphql/analysis/ast/field_usage.rb

@@ -40,12 +40,12 @@ module GraphQL
             end
 
             if argument.definition.type.kind.input_object?
-              extract_deprecated_arguments(argument.value.arguments.argument_values)
+              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
             elsif argument.definition.type.list? && !argument.value.nil?
               argument
                 .value
                 .select { |value| value.respond_to?(:arguments) }
-                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) }
+                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
             end
           end
         end

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -23,18 +23,22 @@ module GraphQL
 
           attr_reader :field_definition, :response_path, :query
 
-          # @param node [Language::Nodes::Field] The AST node; used for providing argument values when necessary
+          # @param parent_type [Class] The owner of `field_definition`
           # @param field_definition [GraphQL::Field, GraphQL::Schema::Field] Used for getting the `.complexity` configuration
           # @param query [GraphQL::Query] Used for `query.possible_types`
           # @param response_path [Array<String>] The path to the response key for the field
-          def initialize(node, field_definition, query, response_path)
-            @node = node
+          def initialize(parent_type, field_definition, query, response_path)
+            @parent_type = parent_type
             @field_definition = field_definition
             @query = query
             @response_path = response_path
             @scoped_children = nil
+            @nodes = []
           end
 
+          # @return [Array<GraphQL::Language::Nodes::Field>]
+          attr_reader :nodes
+
           # Returns true if this field has no selections, ie, it's a scalar.
           # We need a quick way to check whether we should continue traversing.
           def terminal?
@@ -50,16 +54,7 @@ module GraphQL
           end
 
           def own_complexity(child_complexity)
-            defined_complexity = @field_definition.complexity
-            case defined_complexity
-            when Proc
-              arguments = @query.arguments_for(@node, @field_definition)
-              defined_complexity.call(@query.context, arguments.keyword_arguments, child_complexity)
-            when Numeric
-              defined_complexity + child_complexity
-            else
-              raise("Invalid complexity: #{defined_complexity.inspect} on #{@field_definition.name}")
-            end
+            @field_definition.calculate_complexity(query: @query, nodes: @nodes, child_complexity: child_complexity)
           end
         end
 
@@ -79,7 +74,8 @@ module GraphQL
           # then the query would have been rejected as invalid.
           complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
 
-          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(node, visitor.field_definition, visitor.query, visitor.response_path)
+          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
+          complexity.nodes.push(node)
           # Push it on the stack.
           complexities_on_type.push(complexity)
         end

data/lib/graphql/analysis/ast/visitor.rb

@@ -100,7 +100,8 @@ module GraphQL
         def on_field(node, parent)
           @response_path.push(node.alias || node.name)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name)
+          # This could be nil if the previous field wasn't found:
+          field_definition = parent_type && @schema.get_field(parent_type, node.name, @query.context)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
@@ -138,14 +139,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.arguments[node.name]
+              arg_type.get_argument(node.name, @query.context)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            directive_defn.arguments[node.name]
+            directive_defn.get_argument(node.name, @query.context)
           elsif (field_defn = @field_definitions.last)
-            field_defn.arguments[node.name]
+            field_defn.get_argument(node.name, @query.context)
           else
             nil
           end

data/lib/graphql/argument.rb

@@ -3,7 +3,7 @@ module GraphQL
   # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
+    deprecated_accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
     attr_reader :default_value
     attr_accessor :description, :name, :as, :deprecation_reason
     attr_accessor :ast_node

data/lib/graphql/backtrace/table.rb

@@ -89,7 +89,7 @@ module GraphQL
             "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
             "#{context_entry.field.path}#{field_alias ? " as #{field_alias}" : ""}",
             "#{context_entry.object.object.inspect}",
-            context_entry.arguments.to_h.inspect,
+            context_entry.arguments.to_h.inspect, # rubocop:disable Development/ContextIsPassedCop -- unrelated method
             Backtrace::InspectResult.inspect_result(value),
           ]
           if (parent = context_entry.parent_frame)

data/lib/graphql/base_type.rb

@@ -8,7 +8,7 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     include GraphQL::Relay::TypeExtensions
 
-    accepts_definitions :name, :description,
+    deprecated_accepts_definitions :name, :description,
         :introspection,
         :default_scalar,
         :default_relay,
@@ -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/dataloader/source.rb

@@ -138,8 +138,8 @@ module GraphQL
       # @api private
       def result_for(key)
         if !@results.key?(key)
-          raise <<-ERR
-Invariant: fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
+          raise GraphQL::InvariantError, <<-ERR
+Fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
 
 This key should have been loaded already. This is a bug in GraphQL::Dataloader, please report it on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new.
 ERR

data/lib/graphql/dataloader.rb

@@ -23,8 +23,18 @@ module GraphQL
   #   end
   #
   class Dataloader
-    def self.use(schema)
-      schema.dataloader_class = self
+    class << self
+      attr_accessor :default_nonblocking
+    end
+
+    AsyncDataloader = Class.new(self) { self.default_nonblocking = true }
+
+    def self.use(schema, nonblocking: nil)
+      schema.dataloader_class = if nonblocking
+        AsyncDataloader
+      else
+        self
+      end
     end
 
     # Call the block with a Dataloader instance,
@@ -39,9 +49,16 @@ module GraphQL
       result
     end
 
-    def initialize
+    def initialize(nonblocking: self.class.default_nonblocking)
       @source_cache = Hash.new { |h, k| h[k] = {} }
       @pending_jobs = []
+      if !nonblocking.nil?
+        @nonblocking = nonblocking
+      end
+    end
+
+    def nonblocking?
+      @nonblocking
     end
 
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
@@ -50,7 +67,7 @@ module GraphQL
     # @param batch_parameters [Array<Object>]
     # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
     #   and cached for the lifetime of this {Multiplex}.
-    if RUBY_VERSION < "3"
+    if RUBY_VERSION < "3" || RUBY_ENGINE != "ruby" # truffle-ruby wasn't doing well with the implementation below
       def with(source_class, *batch_args)
         batch_key = source_class.batch_key_for(*batch_args)
         @source_cache[source_class][batch_key] ||= begin
@@ -117,6 +134,9 @@ module GraphQL
 
     # @api private Move along, move along
     def run
+      if @nonblocking && !Fiber.scheduler
+        raise "`nonblocking: true` requires `Fiber.scheduler`, assign one with `Fiber.set_scheduler(...)` before executing GraphQL."
+      end
       # At a high level, the algorithm is:
       #
       #  A) Inside Fibers, run jobs from the queue one-by-one
@@ -137,6 +157,8 @@ module GraphQL
       #
       pending_fibers = []
       next_fibers = []
+      pending_source_fibers = []
+      next_source_fibers = []
       first_pass = true
 
       while first_pass || (f = pending_fibers.shift)
@@ -174,31 +196,27 @@ module GraphQL
           # This is where an evented approach would be even better -- can we tell which
           # fibers are ready to continue, and continue execution there?
           #
-          source_fiber_queue = if (first_source_fiber = create_source_fiber)
-            [first_source_fiber]
-          else
-            nil
+          if (first_source_fiber = create_source_fiber)
+            pending_source_fibers << first_source_fiber
           end
 
-          if source_fiber_queue
-            while (outer_source_fiber = source_fiber_queue.shift)
+          while pending_source_fibers.any?
+            while (outer_source_fiber = pending_source_fibers.pop)
               resume(outer_source_fiber)
-
-              # If this source caused more sources to become pending, run those before running this one again:
-              next_source_fiber = create_source_fiber
-              if next_source_fiber
-                source_fiber_queue << next_source_fiber
-              end
-
               if outer_source_fiber.alive?
-                source_fiber_queue << outer_source_fiber
+                next_source_fibers << outer_source_fiber
+              end
+              if (next_source_fiber = create_source_fiber)
+                pending_source_fibers << next_source_fiber
               end
             end
+            join_queues(pending_source_fibers, next_source_fibers)
+            next_source_fibers.clear
           end
           # Move newly-enqueued Fibers on to the list to be resumed.
           # Clear out the list of next-round Fibers, so that
           # any Fibers that pause can be put on it.
-          pending_fibers.concat(next_fibers)
+          join_queues(pending_fibers, next_fibers)
           next_fibers.clear
         end
       end
@@ -213,6 +231,14 @@ module GraphQL
       nil
     end
 
+    def join_queues(previous_queue, next_queue)
+      if @nonblocking
+        Fiber.scheduler.run
+        next_queue.select!(&:alive?)
+      end
+      previous_queue.concat(next_queue)
+    end
+
     private
 
     # If there are pending sources, return a fiber for running them.
@@ -266,9 +292,16 @@ module GraphQL
         fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
       end
 
-      Fiber.new do
-        fiber_locals.each { |k, v| Thread.current[k] = v }
-        yield
+      if @nonblocking
+        Fiber.new(blocking: false) do
+          fiber_locals.each { |k, v| Thread.current[k] = v }
+          yield
+        end
+      else
+        Fiber.new do
+          fiber_locals.each { |k, v| Thread.current[k] = v }
+          yield
+        end
       end
     end
   end

data/lib/graphql/date_encoding_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::ISO8601Date` is asked to return a value
+  # that cannot be parsed to a Ruby Date.
+  #
+  # @see GraphQL::Types::ISO8601Date which raises this error
+  class DateEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :date_value
+
+    def initialize(value)
+      @date_value = value
+      super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+    end
+  end
+end

data/lib/graphql/define/instance_definable.rb

@@ -167,6 +167,21 @@ ERR
         # Each symbol in `accepts` will be assigned with `{key}=`.
         # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
         def accepts_definitions(*accepts)
+          deprecated_caller = caller(0, 1).first
+          if deprecated_caller.include?("lib/graphql")
+            deprecated_caller = caller(2, 10).find { |c| !c.include?("lib/graphql") }
+          end
+
+          if deprecated_caller
+            GraphQL::Deprecation.warn <<-ERR
+#{self}.accepts_definitions will be removed in GraphQL-Ruby 2.0; use a class-based definition instead. See https://graphql-ruby.org/schema/class_based_api.html.
+  -> called from #{deprecated_caller}
+ERR
+          end
+          deprecated_accepts_definitions(*accepts)
+        end
+
+        def deprecated_accepts_definitions(*accepts)
           new_assignments = if accepts.last.is_a?(Hash)
             accepts.pop.dup
           else

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/directive.rb

@@ -8,7 +8,7 @@ module GraphQL
   #
   class Directive
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
+    deprecated_accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
 
     attr_accessor :locations, :arguments, :name, :description, :arguments_class
     attr_accessor :ast_node
@@ -105,7 +105,3 @@ module GraphQL
     end
   end
 end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"

data/lib/graphql/enum_type.rb

@@ -4,7 +4,7 @@ module GraphQL
   class EnumType < GraphQL::BaseType
     extend Define::InstanceDefinable::DeprecatedDefine
 
-    accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
+    deprecated_accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
     ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
     attr_accessor :ast_node
 
@@ -34,10 +34,14 @@ module GraphQL
     end
 
     # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
-    def values
+    def values(_context = nil)
       @values_by_name
     end
 
+    def enum_values(_context = nil)
+      values.values
+    end
+
     def kind
       GraphQL::TypeKinds::ENUM
     end
@@ -68,7 +72,7 @@ module GraphQL
     class EnumValue
       include GraphQL::Define::InstanceDefinable
       ATTRIBUTES = [:name, :description, :deprecation_reason, :value]
-      accepts_definitions(*ATTRIBUTES)
+      deprecated_accepts_definitions(*ATTRIBUTES)
       attr_accessor(*ATTRIBUTES)
       attr_accessor :ast_node
       ensure_defined(*ATTRIBUTES)

data/lib/graphql/execution/errors.rb

@@ -111,6 +111,7 @@ module GraphQL
           runtime_info = ctx.namespace(:interpreter) || {}
           obj = runtime_info[:current_object]
           args = runtime_info[:current_arguments]
+          args = args && args.keyword_arguments
           field = runtime_info[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object

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

@@ -59,7 +59,7 @@ module GraphQL
           @empty
         end
 
-        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values, :size, :to_h
         def_delegators :argument_values, :each_value
 
         def inspect

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

@@ -31,8 +31,10 @@ module GraphQL
           # If any jobs were enqueued, run them now,
           # since this might have been called outside of execution.
           # (The jobs are responsible for updating `result` in-place.)
-          @dataloader.run_isolated do
-            @storage[ast_node][argument_owner][parent_object]
+          if !@storage.key?(ast_node) || !@storage[ast_node].key?(argument_owner)
+            @dataloader.run_isolated do
+              @storage[ast_node][argument_owner][parent_object]
+            end
           end
           # Ack, the _hash_ is updated, but the key is eventually
           # overridden with an immutable arguments instance.
@@ -71,11 +73,11 @@ module GraphQL
           when Array
             ast_arg_or_hash_or_value.map { |v| prepare_args_hash(query, v) }
           when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
-            if ast_arg_or_hash_or_value.arguments.empty?
+            if ast_arg_or_hash_or_value.arguments.empty? # rubocop:disable Development/ContextIsPassedCop -- AST-related
               return NO_ARGUMENTS
             end
             args_hash = {}
-            ast_arg_or_hash_or_value.arguments.each do |arg|
+            ast_arg_or_hash_or_value.arguments.each do |arg| # rubocop:disable Development/ContextIsPassedCop -- AST-related
               v = prepare_args_hash(query, arg.value)
               if v != NO_VALUE_GIVEN
                 args_hash[arg.name] = v