lighthouse-graphql 0.5.0 → 0.6.0

data/lib/generators/lighthouse/install/install_generator.rb

@@ -4,50 +4,66 @@ require 'rails/generators'
 require 'generators/graphql/install_generator'
 require 'lighthouse-graphql'
 require_relative '../base_classes'
+require_relative 'graphql_ruby_install'
 
-# `rails generate lighthouse:install` — sets a Rails app up for Lighthouse, on
-# top of graphql-ruby's own install, which it runs first (`graphql:install
-# --no-relay --skip-graphiql --skip-query-logs`, keeping the files the app has):
-# graphql-ruby writes the base classes every graphql-ruby app has (Types::Base*,
-# Resolvers::BaseResolver, Mutations::BaseMutation), its controller and route.
-# Lighthouse then puts its own over what graphql-ruby wrote in this run:
+# `rails generate lighthouse:install` — puts Lighthouse on top of graphql-ruby's
+# own install (`rails g graphql:install`, with whichever of its options the app
+# chose: --relay, --batch, --skip-mutation-root-type, --schema, --directory,
+# ...). When the app has none, it runs graphql:install first, with its
+# defaults. It then adapts what graphql-ruby wrote, instead of writing its own:
 #
-# - the schema class, built from the SDL (graphql-ruby's is code-first);
-# - the controller, with Lighthouse::GraphQL::Controller;
-# - no Types::QueryType / MutationType: the SDL declares the root types;
-# - Mutations::BaseMutation a GraphQL::Schema::Mutation, as the SDL declares a
-#   mutation's arguments (graphql-ruby's is a RelayClassicMutation, one `input:`);
+# - the schema class (`class AppSchema < GraphQL::Schema`) becomes Lighthouse's,
+#   built from the SDL on everything graphql-ruby wrote: its base types, base
+#   resolver and base mutation, and its code-first Types::QueryType /
+#   MutationType, which the SDL's root types extend, so their `field`s (Relay's
+#   `node` / `nodes`, what `graphql:mutation` adds) stay. Its Relay
+#   Types::NodeType is the SDL's Node. Everything else in the class is
+#   graphql-ruby's and stays, but the `resolve_type` stub (Lighthouse resolves
+#   types) and the root types it is built on;
+# - the example `test_field` goes from the root types;
+# - graphql-ruby's base object, interface, union and scalar include
+#   Lighthouse::GraphQL::Type, so every type class (Types::QueryType,
+#   Types::NodeType, what `graphql:object` writes) is Lighthouse's;
+# - with --batch, the schema uses GraphQL::Dataloader too, which Lighthouse's
+#   directives batch through;
+# - graphql-ruby's controller, as its install wrote it, becomes one with
+#   Lighthouse::GraphQL::Controller.
 #
-# and adds the initializer, a starter SDL file, Subscriptions::BaseSubscription
-# and the graphql-config file IDEs read. Rerunning it skips what is in place. A
-# schema class or controller the app had before is kept (pass --force to replace
-# it), so an app already serving a graphql-ruby schema keeps doing so until it
-# is pointed at ours.
+# It adds the initializer, a starter SDL file and the graphql-config file IDEs
+# read, and with --subscriptions, Subscriptions::BaseSubscription. Rerunning it
+# skips what is in place.
 class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
   include Lighthouse::Generators::BaseClasses
+  include Lighthouse::Generators::GraphqlRubyInstall
 
   CONTROLLER = 'app/controllers/graphql_controller.rb'
-  ROOT_TYPES = %w[app/graphql/types/query_type.rb app/graphql/types/mutation_type.rb].freeze
-  BASE_MUTATION = 'app/graphql/mutations/base_mutation.rb'
 
   source_root File.expand_path('templates', __dir__)
 
-  desc 'Install Lighthouse: initializer, starter schema, schema class, base classes, controller, route and IDE config.'
+  desc "Install Lighthouse on graphql-ruby's install: schema class, base classes, controller, initializer, starter SDL and IDE config."
 
-  class_option :schema, type: :string, default: 'AppSchema',
-                        desc: 'Name of the schema constant to generate'
+  class_option :schema, type: :string,
+                        desc: "The schema class to adopt; for graphql:install, when it runs, its name (default: graphql-ruby's)"
   class_option :sdl_folder, type: :string, default: 'graphql',
                             desc: 'Folder, relative to the app root, holding the *.graphql files'
+  class_option :subscriptions, type: :boolean, default: false,
+                               desc: 'Add Subscriptions::BaseSubscription, the base of the classes Subscription fields resolve to'
   class_option :skip_controller, type: :boolean, default: false,
-                                 desc: 'Skip the GraphqlController and its route'
+                                 desc: "Leave graphql-ruby's GraphqlController as it is"
   class_option :skip_ide, type: :boolean, default: false,
                           desc: 'Skip graphql.config.yml and the .gitignore entries for the IDE helper files'
 
-  # graphql-ruby's install, for the base classes. What it writes that Lighthouse
-  # replaces is noted, so a file the app had before is never touched.
+  # graphql-ruby's install: the app's, or one now, with graphql-ruby's defaults.
   def install_graphql_ruby
-    @before = ([schema_path, CONTROLLER, BASE_MUTATION] + ROOT_TYPES).select { |path| exist?(path) }
-    invoke 'graphql:install', [], schema: schema_name, relay: false, skip_graphiql: true, skip_query_logs: true, skip: true
+    return if schema_path
+
+    say_status :invoke, 'graphql:install (no graphql-ruby schema found)', :blue
+    invoke 'graphql:install', [], graphql_install_options
+    @schema_path = nil
+    return if schema_path
+
+    raise Thor::Error, "No graphql-ruby schema class (class #{options[:schema] || 'AppSchema'} < GraphQL::Schema) under app/: " \
+                       'run `bin/rails g graphql:install` first.'
   end
 
   def create_initializer
@@ -63,38 +79,60 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
     template 'schema.graphql.tt', File.join(sdl_folder, 'schema.graphql')
   end
 
-  def create_schema_class
-    return if keep_existing?(schema_path)
-
-    template 'schema.rb.tt', schema_path, force: true
+  # Subscriptions::BaseSubscription, which graphql-ruby has none of (see BaseClasses).
+  def create_base_subscription
+    write_base_class(:subscriptions, Lighthouse::Config.namespaces[:subscriptions].first) if options[:subscriptions]
   end
 
-  # The SDL declares the root types: graphql-ruby's code-first ones go. Not when
-  # the app keeps a code-first schema of its own, which graphql-ruby's install
-  # pointed at them.
-  def remove_root_types
-    return unless exist?(schema_path) && File.read(File.join(destination_root, schema_path)).include?('RbLightHouse.get_schema')
+  # graphql-ruby's schema class, built by Lighthouse from the SDL on its classes.
+  def adopt_schema_class
+    source = read(schema_path)
+    if lighthouse?(source)
+      say_status :skip, "#{schema_path} is Lighthouse's already", :yellow
+      return
+    end
 
-    ROOT_TYPES.each { |path| remove_file path unless before?(path) }
+    declaration = /^([ \t]*)class (\S+) < GraphQL::Schema[ \t]*\n/
+    indent, name = source.match(declaration).captures
+    gsub_file schema_path, declaration, "#{indent}#{schema_comment(indent)}#{indent}class #{name} < #{schema_superclass(indent)}\n"
+    gsub_file schema_path, /^[ \t]*(query|mutation|subscription)\(Types::(Query|Mutation|Subscription)Type\)\n/, ''
+    gsub_file schema_path, /^(#{indent}\)\n)\n+/, '\\1'
+    gsub_file schema_path, RESOLVE_TYPE_STUB, "\n"
+    add_dataloader if source.include?('use GraphQL::Batch') && source.exclude?('use GraphQL::Dataloader')
   end
 
-  # The SDL declares a mutation's arguments, so its class is a plain
-  # GraphQL::Schema::Mutation, not graphql-ruby's RelayClassicMutation.
-  def adapt_base_mutation
-    return if before?(BASE_MUTATION) || !exist?(BASE_MUTATION)
-
-    gsub_file BASE_MUTATION, 'GraphQL::Schema::RelayClassicMutation', 'GraphQL::Schema::Mutation'
-    gsub_file BASE_MUTATION, /^\s*input_object_class .*\n/, ''
+  # The example field goes; the root types' own fields stay.
+  def adapt_root_types
+    %w[query_type mutation_type subscription_type].each do |name|
+      path = types_path("#{name}.rb")
+      gsub_file path, TEST_FIELD, "\n" if exist?(path) && read(path).match?(TEST_FIELD)
+    end
   end
 
-  # Subscriptions::BaseSubscription, which graphql-ruby has none of (see BaseClasses).
-  def create_base_subscription
-    write_base_class(:subscriptions, Lighthouse::Config.namespaces[:subscriptions].first)
+  # Every type class is Lighthouse's: graphql-ruby's base object, interface,
+  # union and scalar include Lighthouse::GraphQL::Type, so the classes that
+  # inherit from them (Types::QueryType, Types::NodeType, what `graphql:object`
+  # writes) lend their methods to the SDL's types of their name.
+  def adapt_type_bases
+    TYPE_CONCERN_ANCHORS.each do |name, anchor|
+      path = types_path("#{name}.rb")
+      next if !exist?(path) || read(path).include?('Lighthouse::GraphQL::Type')
+
+      indent = read(path)[anchor, 1]
+      next unless indent
+
+      indent += '  ' unless name == 'base_interface'
+      inject_into_file path, "#{indent}# Lighthouse's: the class of the SDL type of its name lends that type its methods.\n" \
+                             "#{indent}include Lighthouse::GraphQL::Type\n", after: anchor
+    end
   end
 
-  def create_controller
-    return remove_graphql_ruby_controller if options[:skip_controller]
-    return if (@kept_controller = keep_existing?(CONTROLLER))
+  # graphql-ruby's controller, as its install wrote it, serves the schema with
+  # Lighthouse's concern. One the app has changed is left alone.
+  def adapt_controller
+    return if options[:skip_controller] || !exist?(CONTROLLER)
+    return if read(CONTROLLER).include?('Lighthouse::GraphQL::Controller')
+    return @kept_controller = true unless graphql_ruby_controller?(read(CONTROLLER))
 
     template 'graphql_controller.rb.tt', CONTROLLER, force: true
   end
@@ -106,8 +144,7 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
     return unless File.exist?(routes)
     return if File.read(routes).include?('graphql#execute')
 
-    # Byte-identical to graphql-ruby's install route, so whichever generator
-    # runs second finds it in place and does not add it again.
+    # Byte-identical to graphql-ruby's install route.
     route 'post "/graphql", to: "graphql#execute"'
   end
 
@@ -128,21 +165,22 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
   def show_next_steps
     serve =
       if @kept_controller
-        "Serve it: #{CONTROLLER} was kept — have it call #{schema_name}.execute(...) to serve Lighthouse's schema."
+        "Serve it: #{CONTROLLER} was changed from graphql-ruby's, so it was kept — " \
+          "include Lighthouse::GraphQL::Controller in it, or keep calling #{schema_name}.execute(...)."
       else
         'Query it:  POST /graphql  {"query": "{ users { data { id name } paginatorInfo { total } } }"}'
       end
 
     say <<~MSG
 
-      Lighthouse is installed. Next steps:
+      Lighthouse is installed on graphql-ruby's install (#{schema_path}). Next steps:
         1. Describe your API in #{sdl_folder}/*.graphql (the starter schema assumes a User model).
-        2. Resolve a field in Ruby when a directive is not enough:  bin/rails g lighthouse:query LatestPosts
-           (it inherits from Resolvers::BaseResolver, which graphql-ruby's install wrote; lighthouse:mutation and
-           lighthouse:subscription write the others)
+        2. Resolve a field in Ruby when a directive is not enough, as in graphql-ruby: a method of
+           Types::QueryType (Query.latestPosts -> #latest_posts), a `field` of its own there,
+           `bin/rails g graphql:mutation`, or a Resolvers::BaseResolver subclass named after the field.
         3. Give a type Ruby methods, a union or interface its resolve_type, a scalar its coercion:
-           bin/rails g graphql:object Post (or graphql:union, graphql:interface, graphql:scalar),
-           then include Lighthouse::GraphQL::Type in the class
+           bin/rails g graphql:object Post (or graphql:union, graphql:interface, graphql:scalar);
+           the class is Lighthouse's through its base (Lighthouse::GraphQL::Type)
         4. Generate the IDE helper files:  bin/rails lighthouse:ide_helper
         5. #{serve}
     MSG
@@ -150,43 +188,26 @@ class Lighthouse::Generators::InstallGenerator < Rails::Generators::Base
 
   private
 
-  # A file the app had before this run is left alone unless --force is given;
-  # one graphql-ruby's install wrote in this run is Lighthouse's to replace.
-  def keep_existing?(path)
-    return false if options[:force] || !before?(path)
-
-    say_status :skip, "#{path} already exists (pass --force to replace it)", :yellow
-    true
-  end
-
-  def before?(path)
-    @before.include?(path)
-  end
-
-  def exist?(path)
-    File.exist?(File.join(destination_root, path))
-  end
-
-  def schema_path
-    File.join('app/graphql', "#{schema_name.underscore}.rb")
-  end
-
-  # --skip-controller: the app serves the schema itself, so graphql-ruby's
-  # controller and route, if its install just wrote them, go.
-  def remove_graphql_ruby_controller
-    return if before?(CONTROLLER)
-
-    remove_file CONTROLLER
-    gsub_file 'config/routes.rb', %r{^\s*post "/graphql", to: "graphql#execute"\n}, '' if exist?('config/routes.rb')
+  def schema_superclass(indent)
+    lines = base_types.map { |key, name| "#{indent}      #{key}: #{name}" }
+    "Lighthouse::GraphQL::RbLightHouse.get_schema(\n#{indent}  options: {\n#{indent}    base_types: {\n" \
+      "#{lines.join(",\n")}\n#{indent}    }\n#{indent}  }\n#{indent})"
   end
 
-  def schema_name
-    options[:schema].camelize
+  def schema_comment(indent)
+    <<~RUBY.gsub(/^/, indent).delete_prefix(indent)
+      # Lighthouse builds the schema from the SDL in #{sdl_folder}/, on the classes graphql-ruby's
+      # install wrote (base_types): the SDL's root types extend the code-first ones, whose
+      # `field`s stay the schema's, and every type, resolver and mutation class inherits from
+      # its kind's base. The rest of the class is graphql-ruby's.
+    RUBY
   end
 
-  # `Resolvers::BaseResolver`, for the schema class template.
-  def base_class_constant(kind)
-    "#{Lighthouse::Config.namespaces[kind].first}::#{base_class_name(kind)}"
+  def add_dataloader
+    anchor = /^([ \t]*)use GraphQL::Batch\n/
+    indent = read(schema_path)[anchor, 1]
+    inject_into_file schema_path, "#{indent}# Lighthouse's directives batch through GraphQL::Dataloader, beside GraphQL::Batch.\n" \
+                                  "#{indent}use GraphQL::Dataloader\n", after: anchor
   end
 
   def sdl_folder

data/lib/generators/lighthouse/install/templates/initializer.rb.tt

@@ -19,8 +19,9 @@ Lighthouse.configure do |config|
   # @event(dispatch:) classes come from :events, and the graphql-ruby analyzers
   # @complexity(resolver:) names from :analyzers. Post.readingTime, with no
   # resolving directive, resolves with Types::PostType#reading_time (a
-  # Types::BaseObject including Lighthouse::GraphQL::Type), from :types. Generate them with
-  # `rails g lighthouse:query|mutation|subscription|type|builder|validator Name`.
+  # Types::BaseObject including Lighthouse::GraphQL::Type), from :types. Generate a
+  # subscription, builder or validator with `rails g lighthouse:subscription|builder|validator Name`,
+  # and a type class with graphql-ruby's `rails g graphql:object|union|interface|scalar Name`.
   # config.namespaces = {
   #   queries: ['Resolvers'], mutations: ['Mutations'], subscriptions: ['Subscriptions'],
   #   builders: ['Builders'], validators: ['Validators'], events: ['Events'], analyzers: ['Analyzers'],
@@ -33,13 +34,6 @@ Lighthouse.configure do |config|
   # Fully-qualified names (containing `::`) are used as-is.
   # config.resolver_namespaces = ['App::Graphql']
 
-  # Store for @cache, @clearCache and @throttle's counts.
-  # config.cache_store = Rails.cache
-
-  # Where @upload stores a file: call(file, disk:, path:, public:) returns what the
-  # argument holds. By default an ActiveStorage blob, and its signed id.
-  # config.upload_store = Lighthouse::GraphQL::UploadStore
-
   # Run @create/@update/@createMany/@updateMany in a database transaction.
   # config.transactional_mutations = true
 

data/lib/lighthouse/caching.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require 'active_support/cache'
 require 'digest'
 require 'json'
 require 'securerandom'
 
-# Keys and invalidation for @cache / @clearCache over Config.cache_store
-# (Rails.cache by default).
+# The app's cache stores, and keys and invalidation for @cache / @clearCache.
+#
+# Lighthouse keeps no store of its own, as PHP Lighthouse uses Laravel's: @cache,
+# @clearCache and APQ use Rails.cache (config.cache_store), and @throttle counts
+# where Rails' own `rate_limit` does, in the controller's cache_store.
 #
 # PHP Lighthouse invalidates with cache tags, which Rails cache stores do not
 # have (and `delete_matched` is not universal). Instead every entry key embeds
@@ -19,8 +23,10 @@ module Lighthouse::GraphQL::Caching
 
   module_function
 
+  # Rails.cache; outside Rails, one in-memory store for the process.
   def store
-    Lighthouse::Config.cache_store
+    rails_cache = ::Rails.cache if defined?(::Rails) && ::Rails.respond_to?(:cache)
+    rails_cache || (@memory_store ||= ActiveSupport::Cache::MemoryStore.new)
   end
 
   def entry_key(type, id, field, args, user_key)

data/lib/lighthouse/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/cache'
-
 module Lighthouse
   # Convenience entrypoint: `Lighthouse.configure { |c| c.resolver_namespaces = [...] }`.
   def self.configure(&block)
@@ -26,21 +24,21 @@ module Lighthouse
 
     # Every setting reset! forgets, so the next read falls back to its default.
     SETTINGS = %i[
-      sdl_folder resolver_namespaces namespaces cache_store transactional_mutations pagination_default_count pagination_max_count
+      sdl_folder resolver_namespaces namespaces transactional_mutations pagination_default_count pagination_max_count
       schema_cache schema_cache_path watch_sdl persisted_queries persisted_queries_store persisted_queries_ttl
       persisted_queries_manifest persisted_queries_only on_error directive_map authenticated_user policy_user authorizer
       feature_checker feature_actor
       convert_empty_strings_to_null
       soft_deletes
       queue_broadcasts broadcast_queue
-      global_id upload_store
+      global_id
     ].freeze
 
     class << self
-      attr_writer :sdl_folder, :resolver_namespaces, :on_error, :authenticated_user, :policy_user, :authorizer, :cache_store,
+      attr_writer :sdl_folder, :resolver_namespaces, :on_error, :authenticated_user, :policy_user, :authorizer,
                   :transactional_mutations, :schema_cache, :watch_sdl, :persisted_queries, :persisted_queries_store, :persisted_queries_only,
                   :queue_broadcasts,
-                  :convert_empty_strings_to_null, :feature_checker, :feature_actor, :global_id, :upload_store
+                  :convert_empty_strings_to_null, :feature_checker, :feature_actor, :global_id
 
       def sdl_folder
         @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.join('graphql').to_s : nil)
@@ -66,16 +64,6 @@ module Lighthouse
         @namespaces = namespaces.merge(overrides.to_h.transform_keys(&:to_sym).transform_values { |v| Array(v) })
       end
 
-      # Store backing @cache and @clearCache. Defaults to Rails.cache.
-      def cache_store
-        @cache_store ||=
-          if defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
-            Rails.cache
-          else
-            ActiveSupport::Cache::MemoryStore.new
-          end
-      end
-
       # --- Subscriptions (used by @broadcast) ----------------------------------
       #
       # queue_broadcasts  perform @broadcast triggers in a Lighthouse::GraphQL::BroadcastJob
@@ -91,7 +79,7 @@ module Lighthouse
       # schema_cache_path     where; default Rails.root/tmp/cache/lighthouse
       # watch_sdl             reload the app (and so the schema) when a .graphql file changes
       # persisted_queries     accept Apollo's Automatic Persisted Queries (PersistedQueries)
-      # persisted_queries_store     where APQ keeps queries; default cache_store
+      # persisted_queries_store     where APQ keeps queries; default Rails.cache
       # persisted_queries_ttl       how long they live there (seconds; nil: until evicted)
       # persisted_queries_manifest  a manifest of trusted operations, served by hash
       # persisted_queries_only      reject any operation not in the manifest
@@ -110,13 +98,8 @@ module Lighthouse
       # and `decode(global_id)` -> [type, id]. Base64 of "Type:id" by default.
       def global_id = @global_id || Lighthouse::GraphQL::GlobalId
 
-      # Stores the file an @upload argument carries: `call(file, disk:, path:,
-      # public:)` returns what the argument holds instead. An ActiveStorage blob's
-      # signed id by default.
-      def upload_store = @upload_store || Lighthouse::GraphQL::UploadStore
-
       def persisted_queries_store
-        @persisted_queries_store || cache_store
+        @persisted_queries_store || Lighthouse::GraphQL::Caching.store
       end
 
       # Pagination defaults, overridden by a directive's defaultCount / maxCount.

data/lib/lighthouse/controller.rb

@@ -24,6 +24,11 @@ require 'json'
 # Cache-Control header the selected fields' @cacheControl hints allow, renders
 # the JSON and dispatches EndRequest. In development an error renders as JSON.
 #
+# A field's @throttle that renders past its limit (its `with:` method, or
+# `head :too_many_requests`, rate_limit's default on Rails 7.2) ends the request
+# with that response, as a before_action that renders does: the operation stops
+# there (Performed), and `execute` renders nothing more.
+#
 # Hooks, private so they are not actions: `graphql_context` (default:
 # `{ current_user: current_user }` when the controller has a current_user, else
 # `{}`), `graphql_schema` and `graphql_variables(param)`. A controller with an
@@ -32,6 +37,11 @@ require 'json'
 module Lighthouse::GraphQL::Controller
   extend ActiveSupport::Concern
 
+  # Raised once a @throttle `with:` method has performed the response: control
+  # flow, as `throw :abort` in a before_action, so no `rescue StandardError` (a
+  # schema's rescue_from) catches it on its way out of the operation.
+  class Performed < Exception; end # rubocop:disable Lint/InheritException
+
   included do
     class_attribute :lighthouse_schema_source, instance_writer: false
   end
@@ -57,7 +67,7 @@ module Lighthouse::GraphQL::Controller
       end
     end
   rescue StandardError => e
-    raise e unless defined?(::Rails) && ::Rails.env.development?
+    raise e unless defined?(::Rails) && ::Rails.env.development? && !rails_response?(e)
 
     lighthouse_development_error(e)
   end
@@ -65,13 +75,18 @@ module Lighthouse::GraphQL::Controller
   private
 
   # Dispatch StartRequest, run the block, dispatch EndRequest with the
-  # response. Only the outermost call dispatches.
+  # response. Only the outermost call dispatches, and stops the block where a
+  # @throttle `with:` method performed the response.
   def lighthouse_request
     return yield if @lighthouse_request_started
 
     @lighthouse_request_started = true
     Lighthouse::Events.dispatch(Lighthouse::Events::StartRequest.new(request))
-    result = yield
+    result = begin
+      yield
+    rescue Performed
+      nil
+    end
     Lighthouse::Events.dispatch(Lighthouse::Events::EndRequest.new(response))
     result
   end
@@ -81,9 +96,11 @@ module Lighthouse::GraphQL::Controller
     respond_to?(:current_user, true) ? { current_user: current_user } : {}
   end
 
-  # graphql_context, with the client's IP (for @throttle) unless it sets its own.
+  # graphql_context, with what @throttle reads unless it sets its own: the
+  # client's IP (rate_limit's default by:) and the controller, whose cache_store,
+  # controller_path and methods rate_limit uses.
   def lighthouse_context
-    { remote_ip: request.remote_ip }.merge(graphql_context)
+    { remote_ip: request.remote_ip, lighthouse_controller: self }.merge(graphql_context)
   end
 
   def graphql_schema
@@ -139,6 +156,12 @@ module Lighthouse::GraphQL::Controller
     Lighthouse::GraphQL::PersistedQueries.multiplex(graphql_schema, operations)
   end
 
+  # An error Rails answers with a status of its own (config.action_dispatch.rescue_responses):
+  # ActionController::TooManyRequests from @throttle is a 429 in development too.
+  def rails_response?(error)
+    ::ActionDispatch::ExceptionWrapper.status_code_for_exception(error.class.name) != 500
+  end
+
   def lighthouse_development_error(error)
     logger.error(error.message)
     logger.error(error.backtrace.join("\n"))

data/lib/lighthouse/directive_resolvers/argument_transforms_resolver.rb

@@ -11,7 +11,7 @@ require_relative 'base'
 #   @hash               the value hashed with BCrypt, for a password column
 #   @drop               the value removed: the resolver never sees it
 #   @bind(class:)       the value replaced by the record(s) it identifies
-#   @upload             the uploaded file stored (Config.upload_store), its blob's signed id passed
+#   @upload             the uploaded file stored with ActiveStorage (UploadStore), its blob's signed id passed
 #
 #   type Mutation {
 #     signUp(email: String! @trim, password: String! @trim @hash, captcha: String @drop): User! @create
@@ -60,26 +60,26 @@ class Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver < Ligh
         "A model class, or a class whose `call(value, context)` returns what the value stands for."
         class: String!
         "The column the value is matched against, for a model."
-        column: String! = "id"
+        column: String = "id"
         "Relations to eager-load on the bound records."
-        with: [String!]! = []
+        with: [String!] = []
         "Pass null instead of failing when no record matches."
-        optional: Boolean! = false
+        optional: Boolean = false
       ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
     GRAPHQL
     'upload' => <<~GRAPHQL.chomp
       """
-      Store the file an Upload argument carries, and pass along what Config.upload_store
-      answers instead: by default, the signed id of an ActiveStorage blob, which an
-      attachment attribute (has_one_attached) attaches.
+      Store the file an Upload argument carries with ActiveStorage, and pass along the
+      signed id of its blob instead, which an attachment attribute (has_one_attached)
+      attaches. This does not change the schema from a client perspective.
       """
       directive @upload(
-        "The storage service to store the file on (an ActiveStorage service name). Defaults to the default one."
+        "The ActiveStorage service to store the file on (config/storage.yml). Defaults to config.active_storage.service."
         disk: String
-        "A prefix for the stored file's key."
-        path: String! = "/"
-        "Accepted for PHP Lighthouse parity: whether files are public is the service's setting."
-        public: Boolean! = false
+        "The directory the stored file's key starts with."
+        path: String = "/"
+        "Whether the file is public. ActiveStorage sets that per service, so it must agree with the service's."
+        public: Boolean = false
       ) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
     GRAPHQL
   }.freeze
@@ -154,8 +154,8 @@ class Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver < Ligh
     send(TRANSFORMS.fetch(directive.name), directive, argument, value, ctx)
   end
 
-  def decode_global_id(directive, _argument, value, _ctx)
-    decode(value, Lighthouse::Support::DirectiveArgs.literal(directive, 'decode') || 'ARRAY')
+  def decode_global_id(directive, _argument, value, ctx)
+    decode(value, Lighthouse::Support::DirectiveArgs.literal(directive, 'decode') || 'ARRAY', ctx)
   end
 
   def trim_value(_directive, _argument, value, _ctx) = trim(value)
@@ -166,13 +166,13 @@ class Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver < Ligh
     return value.map { |item| upload(directive, argument, item, ctx) } if value.is_a?(Array)
 
     options = %w[disk path public].to_h { |name| [name.to_sym, Lighthouse::Support::DirectiveArgs.literal(directive, name)] }
-    Lighthouse::Config.upload_store.call(value, **options.compact)
+    Lighthouse::GraphQL::UploadStore.call(value, argument: argument.graphql_name, **options)
   end
 
-  def decode(value, mode)
-    return value.map { |item| decode(item, mode) } if value.is_a?(Array)
+  def decode(value, mode, ctx = nil)
+    return value.map { |item| decode(item, mode, ctx) } if value.is_a?(Array)
 
-    type, id = Lighthouse::GraphQL::GlobalId.decode!(value)
+    type, id = Lighthouse::GraphQL::GlobalId.decode!(value, ctx)
     { 'TYPE' => type, 'ID' => id }.fetch(mode.to_s, [type, id])
   end
 

data/lib/lighthouse/directive_resolvers/cache_resolvers.rb

@@ -3,7 +3,7 @@
 require_relative 'base'
 
 module Lighthouse::GraphQL::DirectiveResolvers
-  # @cache — keep a field's resolved value in Config.cache_store (Rails.cache).
+  # @cache — keep a field's resolved value in Rails.cache (Caching.store).
   #
   # The key covers the parent type and its key (the field marked @cacheKey,
   # else the first `ID` field; none on Query/Mutation), the field, and its

data/lib/lighthouse/directive_resolvers/global_id_resolver.rb

@@ -51,7 +51,9 @@ class Lighthouse::GraphQL::DirectiveResolvers::GlobalIdDirectiveResolver < Light
 
     install(target_type_class, lambda do |obj, args, ctx|
       id = inner.call(obj, args, ctx)
-      id.nil? ? nil : Lighthouse::Config.global_id.encode(type_name, id)
+      next if id.nil?
+
+      Lighthouse::GraphQL::GlobalId.encode_field(target_type_class, obj, id, ctx) || Lighthouse::Config.global_id.encode(type_name, id)
     end)
   end
 end