graphql 1.12.17 → 1.12.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c9089e4578454f473996553a4771e4086e51b2b2db17fc31a579ab28019bd39
-  data.tar.gz: f45a70c81394f35c86d1610491f106e39899bc2c927a6a6d13e9e6533bc3bc85
+  metadata.gz: 6fa9800286687f6236697bf1f3eed4f3342b40fbbbebc64c472a7d791442bce4
+  data.tar.gz: a74ed6cf70cf2f626c2339a8377ada5dea5491eb3e53a1e1783b4a7a8dd8bebc
 SHA512:
-  metadata.gz: b7231b5e00a336439d15d469a383cd7e211e305961d4a4b431e8a97f5e483819bbd87de3d7cfffc9b6677b8175f700e012cd9ee4a0c92fa47005455a14893d3c
-  data.tar.gz: 98495c2b24d65ef90d7f5e1036956349ea79d03ea192de6ed06e517657f49b4e0e9c748c8a28d54aac24e96b42f52eea5d4cbfbca801a4389b1515804296831a
+  metadata.gz: 41c6592dbd0cd27e82f036f271c71098a14c2b10d7cc700fc680caa1133b0a148a730b9e15d5a4d04c98f72bfd4a418d8ae63b09f327193f80af2220fc399fc0
+  data.tar.gz: cb35e9d298bc92431ae561e8c663c00fcf899c1cc1c1daca9730717ba6636f9eb177af40b1314e55f73a411d2a78eeaadc2d2c6b34b583cd3fbe7525d18a8139

data/lib/generators/graphql/object_generator.rb

@@ -12,7 +12,8 @@ module Graphql
     #
     # Add the Node interface with `--node`.
     class ObjectGenerator < TypeGeneratorBase
-      desc "Create a GraphQL::ObjectType with the given name and fields"
+      desc "Create a GraphQL::ObjectType with the given name and fields." \
+      "If the given type name matches an existing ActiveRecord model, the generated type will automatically include fields for the models database columns."
       source_root File.expand_path('../templates', __FILE__)
 
       argument :custom_fields,

data/lib/generators/graphql/relay.rb

@@ -32,20 +32,28 @@ module Graphql
 
   # Return a string UUID for `object`
   def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    object_id = object.to_global_id.to_s
+    # Remove this redundant prefix to make IDs shorter:
+    object_id = object_id.sub("gid://\#{GlobalID.app}/", "")
+    encoded_id = Base64.urlsafe_encode64(object_id)
+    # Remove the "=" padding
+    encoded_id = encoded_id.sub(/=+/, "")
+    # Add a type hint
+    type_hint = type_definition.graphql_name.first
+    "\#{type_hint}_\#{encoded_id}"
   end
 
   # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
+  def self.object_from_id(encoded_id_with_hint, query_ctx)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    # Split off the type hint
+    _type_hint, encoded_id = encoded_id_with_hint.split("_", 2)
+    # Decode the ID
+    id = Base64.urlsafe_decode64(encoded_id)
+    # Rebuild it for Rails then find the object:
+    full_global_id = "gid://\#{GlobalID.app}/\#{id}"
+    GlobalID::Locator.locate(full_global_id)
   end
 RUBY
         inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false

data/lib/generators/graphql/templates/schema.erb

@@ -4,11 +4,23 @@ class <%= schema_name %> < GraphQL::Schema
 <% if options[:batch] %>
   # GraphQL::Batch setup:
   use GraphQL::Batch
+<% else %>
+  # For batch-loading (see https://graphql-ruby.org/dataloader/overview.html)
+  use GraphQL::Dataloader
 <% end %>
+  # GraphQL-Ruby calls this when something goes wrong while running a query:
+  def self.type_error(err, context)
+    # if err.is_a?(GraphQL::InvalidNullError)
+    #   # report to your bug tracker here
+    #   return nil
+    # end
+    super
+  end
+
   # Union and Interface Resolution
   def self.resolve_type(abstract_type, obj, ctx)
-    # TODO: Implement this function
-    # to return the correct object type for `obj`
+    # TODO: Implement this method
+    # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
 end

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

@@ -37,7 +37,7 @@ module GraphQL
 
             if argument.definition.type.kind.input_object?
               extract_deprecated_arguments(argument.value.arguments.argument_values)
-            elsif argument.definition.type.list?
+            elsif argument.definition.type.list? && !argument.value.nil?
               argument
                 .value
                 .select { |value| value.respond_to?(:arguments) }

data/lib/graphql/dataloader/source.rb

@@ -6,7 +6,11 @@ module GraphQL
       # Called by {Dataloader} to prepare the {Source}'s internal state
       # @api private
       def setup(dataloader)
+        # These keys have been requested but haven't been fetched yet
         @pending_keys = []
+        # These keys have been passed to `fetch` but haven't been finished yet
+        @fetching_keys = []
+        # { key => result }
         @results = {}
         @dataloader = dataloader
       end
@@ -64,29 +68,46 @@ module GraphQL
       # Then run the batch and update the cache.
       # @return [void]
       def sync
+        pending_keys = @pending_keys.dup
         @dataloader.yield
+        iterations = 0
+        while pending_keys.any? { |k| !@results.key?(k) }
+          iterations += 1
+          if iterations > 1000
+            raise "#{self.class}#sync tried 1000 times to load pending keys (#{pending_keys}), but they still weren't loaded. There is likely a circular dependency."
+          end
+          @dataloader.yield
+        end
+        nil
       end
 
       # @return [Boolean] True if this source has any pending requests for data.
       def pending?
-        @pending_keys.any?
+        !@pending_keys.empty?
       end
 
       # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
       # @api private
       # @return [void]
       def run_pending_keys
+        if !@fetching_keys.empty?
+          @pending_keys -= @fetching_keys
+        end
         return if @pending_keys.empty?
         fetch_keys = @pending_keys.uniq
+        @fetching_keys.concat(fetch_keys)
         @pending_keys = []
         results = fetch(fetch_keys)
         fetch_keys.each_with_index do |key, idx|
           @results[key] = results[idx]
         end
+        nil
       rescue StandardError => error
         fetch_keys.each { |key| @results[key] = error }
       ensure
-        nil
+        if fetch_keys
+          @fetching_keys -= fetch_keys
+        end
       end
 
       # These arguments are given to `dataloader.with(source_class, ...)`. The object
@@ -107,6 +128,8 @@ module GraphQL
         [*batch_args, **batch_kwargs]
       end
 
+      attr_reader :pending_keys
+
       private
 
       # Reads and returns the result for the key from the internal cache, or raises an error if the result was an error
@@ -114,6 +137,13 @@ module GraphQL
       # @return [Object] The result from {#fetch} for `key`.
       # @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})
+
+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
+        end
         result = @results[key]
 
         raise result if result.class <= StandardError

data/lib/graphql/dataloader.rb

@@ -90,6 +90,16 @@ module GraphQL
     # Use a self-contained queue for the work in the block.
     def run_isolated
       prev_queue = @pending_jobs
+      prev_pending_keys = {}
+      @source_cache.each do |source_class, batched_sources|
+        batched_sources.each do |batch_args, batched_source_instance|
+          if batched_source_instance.pending?
+            prev_pending_keys[batched_source_instance] = batched_source_instance.pending_keys.dup
+            batched_source_instance.pending_keys.clear
+          end
+        end
+      end
+
       @pending_jobs = []
       res = nil
       # Make sure the block is inside a Fiber, so it can `Fiber.yield`
@@ -100,6 +110,9 @@ module GraphQL
       res
     ensure
       @pending_jobs = prev_queue
+      prev_pending_keys.each do |source_instance, pending_keys|
+        source_instance.pending_keys.concat(pending_keys)
+      end
     end
 
     # @api private Move along, move along

data/lib/graphql/deprecated_dsl.rb

@@ -38,9 +38,17 @@ module GraphQL
       end
     end
 
-    TYPE_CLASSES.each do |type_class|
-      refine type_class.singleton_class do
-        include Methods
+    if defined?(::Refinement) && Refinement.private_method_defined?(:import_methods)
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          import_methods Methods
+        end
+      end
+    else
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          include Methods
+        end
       end
     end
   end

data/lib/graphql/deprecation.rb

@@ -3,11 +3,7 @@
 module GraphQL
   module Deprecation
     def self.warn(message)
-      if defined?(ActiveSupport::Deprecation)
-        ActiveSupport::Deprecation.warn(message)
-      else
-        Kernel.warn(message)
-      end
+      Kernel.warn(message)
     end
   end
 end

data/lib/graphql/integer_encoding_error.rb

@@ -12,9 +12,25 @@ module GraphQL
     # The value which couldn't be encoded
     attr_reader :integer_value
 
-    def initialize(value)
+    # @return [GraphQL::Schema::Field] The field that returned a too-big integer
+    attr_reader :field
+
+    # @return [Array<String, Integer>] Where the field appeared in the GraphQL response
+    attr_reader :path
+
+    def initialize(value, context:)
       @integer_value = value
-      super("Integer out of bounds: #{value}. \nConsider using ID or GraphQL::Types::BigInt instead.")
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "Integer out of bounds: #{value}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". Consider using ID or GraphQL::Types::BigInt instead."
+      super(message)
     end
   end
 end

data/lib/graphql/pagination/connections.rb

@@ -70,23 +70,42 @@ module GraphQL
         wrappers = context ? context.namespace(:connections)[:all_wrappers] : all_wrappers
         impl = wrapper_for(items, wrappers: wrappers)
 
-        if impl.nil?
-          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
+        if impl
+          impl.new(
+            items,
+            context: context,
+            parent: parent,
+            field: field,
+            max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
+            first: arguments[:first],
+            after: arguments[:after],
+            last: arguments[:last],
+            before: arguments[:before],
+            arguments: arguments,
+            edge_class: edge_class_for_field(field),
+          )
+        else
+          begin
+            connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(items)
+            if parent.is_a?(GraphQL::Schema::Object)
+              parent = parent.object
+            end
+            connection_class.new(
+              items,
+              arguments,
+              field: field,
+              max_page_size: field.max_page_size,
+              parent: parent,
+              context: context,
+            )
+          rescue RuntimeError => err
+            if err.message.include?("No connection implementation to wrap")
+              raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
+            else
+              raise err
+            end
+          end
         end
-
-        impl.new(
-          items,
-          context: context,
-          parent: parent,
-          field: field,
-          max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
-          first: arguments[:first],
-          after: arguments[:after],
-          last: arguments[:last],
-          before: arguments[:before],
-          arguments: arguments,
-          edge_class: edge_class_for_field(field),
-        )
       end
 
       # use an override if there is one

data/lib/graphql/query/validation_pipeline.rb

@@ -72,7 +72,7 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout)
+          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
           @internal_representation = validation_result[:irep]
 

data/lib/graphql/schema/argument.rb

@@ -260,38 +260,67 @@ module GraphQL
           type.coerce_input(value, context)
         end
 
-        # TODO this should probably be inside after_lazy
-        if loads && !from_resolver?
-          loaded_value = if type.list?
-            loaded_values = coerced_value.map { |val| owner.load_application_object(self, loads, val, context) }
-            context.schema.after_any_lazies(loaded_values) { |result| result }
-          else
-            context.query.with_error_handling do
-              owner.load_application_object(self, loads, coerced_value, context)
+        # If this isn't lazy, then the block returns eagerly and assigns the result here
+        # If it _is_ lazy, then we write the lazy to the hash, then update it later
+        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
+          if loads && !from_resolver?
+            loaded_value = context.query.with_error_handling do
+              load_and_authorize_value(owner, coerced_value, context)
             end
           end
-        end
 
-        coerced_value = if loaded_value
-          loaded_value
-        else
-          coerced_value
-        end
+          maybe_loaded_value = loaded_value || resolved_coerced_value
+          context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
+            owner.validate_directive_argument(self, resolved_loaded_value)
+            prepared_value = context.schema.error_handler.with_error_handling(context) do
+              prepare_value(parent_object, resolved_loaded_value, context: context)
+            end
 
-        # If this isn't lazy, then the block returns eagerly and assigns the result here
-        # If it _is_ lazy, then we write the lazy to the hash, then update it later
-        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |coerced_value|
-          owner.validate_directive_argument(self, coerced_value)
-          prepared_value = context.schema.error_handler.with_error_handling(context) do
-            prepare_value(parent_object, coerced_value, context: context)
+            # TODO code smell to access such a deeply-nested constant in a distant module
+            argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+              value: prepared_value,
+              definition: self,
+              default_used: default_used,
+            )
           end
+        end
+      end
 
-          # TODO code smell to access such a deeply-nested constant in a distant module
-          argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
-            value: prepared_value,
-            definition: self,
-            default_used: default_used,
-          )
+      def load_and_authorize_value(load_method_owner, coerced_value, context)
+        if coerced_value.nil?
+          return nil
+        end
+        arg_load_method = "load_#{keyword}"
+        if load_method_owner.respond_to?(arg_load_method)
+          custom_loaded_value = if load_method_owner.is_a?(Class)
+            load_method_owner.public_send(arg_load_method, coerced_value, context)
+          else
+            load_method_owner.public_send(arg_load_method, coerced_value)
+          end
+          context.schema.after_lazy(custom_loaded_value) do |custom_value|
+            if loads
+              if type.list?
+                loaded_values = custom_value.each_with_index.map { |custom_val, idx|
+                  id = coerced_value[idx]
+                  load_method_owner.authorize_application_object(self, id, context, custom_val)
+                }
+                context.schema.after_any_lazies(loaded_values, &:itself)
+              else
+                load_method_owner.authorize_application_object(self, coerced_value, context, custom_loaded_value)
+              end
+            else
+              custom_value
+            end
+          end
+        elsif loads
+          if type.list?
+            loaded_values = coerced_value.map { |val| load_method_owner.load_and_authorize_application_object(self, val, context) }
+            context.schema.after_any_lazies(loaded_values, &:itself)
+          else
+            load_method_owner.load_and_authorize_application_object(self, coerced_value, context)
+          end
+        else
+          coerced_value
         end
       end
 

data/lib/graphql/schema/field.rb

@@ -122,6 +122,9 @@ module GraphQL
           else
             kwargs[:type] = type
           end
+          if type.is_a?(Class) && type < GraphQL::Schema::Mutation
+            raise ArgumentError, "Use `field #{name.inspect}, mutation: Mutation, ...` to provide a mutation to this field instead"
+          end
         end
         new(**kwargs, &block)
       end
@@ -510,6 +513,7 @@ module GraphQL
         field_defn
       end
 
+      class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 
       def type
@@ -517,14 +521,21 @@ module GraphQL
           Member::BuildType.parse_type(@function.type, null: false)
         elsif @field
           Member::BuildType.parse_type(@field.type, null: false)
+        elsif @return_type_expr.nil?
+          # Not enough info to determine type
+          message = "Can't determine the return type for #{self.path}"
+          if @resolver_class
+            message += " (it has `resolver: #{@resolver_class}`, consider configuration a `type ...` for that class)"
+          end
+          raise MissingReturnTypeError, message
         else
           Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
         end
-      rescue GraphQL::Schema::InvalidDocumentError => err
+      rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err
         # Let this propagate up
         raise err
       rescue StandardError => err
-        raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: (#{err.class}) #{err.message}", err.backtrace
+        raise MissingReturnTypeError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: (#{err.class}) #{err.message}", err.backtrace
       end
 
       def visible?(context)
@@ -608,8 +619,7 @@ module GraphQL
             if is_authorized
               public_send_field(object, args, ctx)
             else
-              err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
-              ctx.schema.unauthorized_field(err)
+              raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
             end
           end
         rescue GraphQL::UnauthorizedFieldError => err

data/lib/graphql/schema/input_object.rb

@@ -40,11 +40,7 @@ module GraphQL
             # With the interpreter, it's done during `coerce_arguments`
             if loads && !arg_defn.from_resolver? && !context.interpreter?
               value = @ruby_style_hash[ruby_kwargs_key]
-              loaded_value = if arg_defn.type.list?
-                value.map { |val| load_application_object(arg_defn, loads, val, context) }
-              else
-                load_application_object(arg_defn, loads, value, context)
-              end
+              loaded_value = arg_defn.load_and_authorize_value(self, value, context)
               maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
                 overwrite_argument(ruby_kwargs_key, loaded_value)
               end