lighthouse-graphql 0.5.0 → 0.7.0

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

@@ -3,11 +3,13 @@
 # Lighthouse configuration. Every option is optional; the defaults are shown.
 # Reference: https://github.com/Vaz-Innovation/lighthouse-graphql/blob/main/docs/configuration.md
 Lighthouse.configure do |config|
-  # Folder the *.graphql schema files are loaded from.
-<% if default_sdl_folder? -%>
-  # config.sdl_folder = Rails.root.join('graphql').to_s
+  # The schema's entrypoint. It imports the other .graphql files
+  # (#import user.graphql, #import blog/*.graphql), which add to a type
+  # defined elsewhere with `extend type`.
+<% if default_sdl_schema_path? -%>
+  # config.schema_path = Rails.root.join('graphql/schema.graphql').to_s
 <% else -%>
-  config.sdl_folder = Rails.root.join('<%= sdl_folder %>').to_s
+  config.schema_path = Rails.root.join('<%= sdl_schema_path %>').to_s
 <% end -%>
 
   # Where classes named by the schema are looked up, by kind. A Query or Mutation
@@ -19,8 +21,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 +36,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
 
@@ -64,6 +60,11 @@ Lighthouse.configure do |config|
   # Reload the app (and so the schema) when a .graphql file changes.
   # config.watch_sdl = Rails.env.development?
 
+  # Rewrite schema-directives.graphql and programmatic-types.graphql, which your
+  # IDE reads through graphql.config.yml, on boot and on every reload. nil: in
+  # development, when the app has a graphql.config.yml.
+  # config.ide_helper = nil
+
   # Automatic Persisted Queries (Apollo's protocol). Add a GET route too, so
   # hashed queries can be cached by CDNs: get "/graphql", to: "graphql#execute"
   # config.persisted_queries = true

data/lib/lighthouse/ast_builder.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# The manipulation phase, as PHP Lighthouse's ASTBuilder runs it on the
+# stitched schema:
+#
+# 1. DocumentAST.from_source: every type defined once.
+# 2. Type extensions merged into the types they extend. An extension of a
+#    root type that has no definition (`extend type Query` alone) defines it.
+# 3. The type and field manipulators: @hide/@show, @model, @paginate (and the
+#    relation directives' `type:`), @softDeletes, @node.
+# 4. The argument manipulators: each argument directive whose class includes
+#    Contracts::ArgManipulator rewrites its argument (@whereConditions,
+#    @whereHasConditions, @orderBy turn `_` into the input types they generate).
+# 5. The definitions of directives the generated types use (`@enum`).
+#
+# Returns the manipulated SDL; ManipulateAST listeners then see its document.
+module Lighthouse::GraphQL::ASTBuilder
+  Nodes = ::GraphQL::Language::Nodes
+
+  EXTENSION_TO_DEFINITION = {
+    Nodes::ObjectTypeExtension => Nodes::ObjectTypeDefinition,
+    Nodes::InterfaceTypeExtension => Nodes::InterfaceTypeDefinition,
+    Nodes::InputObjectTypeExtension => Nodes::InputObjectTypeDefinition,
+    Nodes::EnumTypeExtension => Nodes::EnumTypeDefinition,
+    Nodes::UnionTypeExtension => Nodes::UnionTypeDefinition,
+    Nodes::ScalarTypeExtension => Nodes::ScalarTypeDefinition
+  }.freeze
+
+  # What each extension adds to its definition, besides directives.
+  MERGED_LISTS = {
+    Nodes::ObjectTypeExtension => %i[fields interfaces],
+    Nodes::InterfaceTypeExtension => %i[fields interfaces],
+    Nodes::InputObjectTypeExtension => %i[fields],
+    Nodes::EnumTypeExtension => %i[values],
+    Nodes::UnionTypeExtension => %i[types],
+    Nodes::ScalarTypeExtension => []
+  }.freeze
+
+  ROOT_TYPES = %w[Query Mutation Subscription].freeze
+
+  OBJECT_LIKE = [Nodes::ObjectTypeDefinition, Nodes::InterfaceTypeDefinition].freeze
+
+  module_function
+
+  def build(sdl, registry: Lighthouse::DirectiveRegistry.default)
+    document_ast = Lighthouse::GraphQL::DocumentAST.from_source(sdl)
+    extend_types(document_ast)
+
+    document_ast = Lighthouse::GraphQL::DocumentAST.from_source(registry.manipulate_sdl(document_ast.to_sdl))
+    apply_arg_manipulators(document_ast, registry)
+
+    Lighthouse::GraphQL::SchemaGenerator.inject_directive_definitions(document_ast.to_sdl)
+  end
+
+  def extend_types(document_ast)
+    document_ast.type_extensions.each do |name, extensions|
+      extensions.each { |extension| extend_type(document_ast, name, extension) }
+    end
+    document_ast.type_extensions.clear
+  end
+
+  def extend_type(document_ast, name, extension)
+    definition = document_ast.types[name] || root_type(document_ast, name, extension)
+    unless definition.is_a?(EXTENSION_TO_DEFINITION.fetch(extension.class))
+      raise Lighthouse::DefinitionError,
+            "The type extension #{name} of kind #{kind(extension)} can not extend a definition of kind #{kind(definition)}."
+    end
+
+    merged = MERGED_LISTS.fetch(extension.class).index_with { |list| merge_unique(definition.public_send(list), extension.public_send(list)) }
+    document_ast.put_type(definition.merge(directives: definition.directives + extension.directives, **merged))
+  end
+
+  # `extend type Query` with no `type Query` anywhere defines it, as in PHP Lighthouse.
+  def root_type(document_ast, name, extension)
+    unless ROOT_TYPES.include?(name) && extension.is_a?(Nodes::ObjectTypeExtension)
+      raise Lighthouse::DefinitionError, "Could not find a base definition #{name} of kind #{kind(extension)} to extend."
+    end
+
+    Nodes::ObjectTypeDefinition.new(name: name, fields: [], interfaces: [], directives: []).tap { |root| document_ast.put_type(root) }
+  end
+
+  # The definition's nodes followed by the extension's; a name in both is an error.
+  def merge_unique(original, addition)
+    names = addition.to_set(&:name)
+    duplicate = original.find { |node| names.include?(node.name) }
+    raise Lighthouse::DefinitionError, "Duplicate definition #{duplicate.name} found when merging." if duplicate
+
+    original + addition
+  end
+
+  def kind(node)
+    node.class.name.demodulize
+  end
+
+  # Every argument of every object and interface field, through the
+  # manipulators of the directives it carries, in their SDL order.
+  def apply_arg_manipulators(document_ast, registry)
+    document_ast.type_names.each do |name|
+      type = document_ast.types[name]
+      next unless OBJECT_LIKE.any? { |kind| type.is_a?(kind) }
+
+      fields = type.fields.map do |field|
+        field.merge(arguments: field.arguments.map { |arg| manipulate_argument(document_ast, registry, arg, field, type) })
+      end
+      document_ast.put_type(type.merge(fields: fields))
+    end
+  end
+
+  def manipulate_argument(document_ast, registry, arg, field, type)
+    manipulated = arg.directives.reduce(arg) do |current, directive|
+      manipulator = registry.arg_manipulator_class(directive.name)
+      manipulator ? manipulator.new(current, directive).manipulate_arg_definition(document_ast, field, type) : current
+    end
+    return manipulated unless placeholder?(manipulated.type)
+
+    raise Lighthouse::DefinitionError,
+          "#{type.name}.#{field.name}(#{arg.name}:) has the placeholder type `_`, which only a directive that generates " \
+          'its type replaces: @whereConditions, @whereHasConditions or @orderBy.'
+  end
+
+  def placeholder?(type)
+    Lighthouse::GraphQL::Directives::GeneratedTypes.placeholder?(type)
+  end
+end

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,24 +24,43 @@ 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
+      schema_path ide_helper 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 :schema_path, :ide_helper, :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
+
+      # The schema's entrypoint, as PHP Lighthouse's `schema_path`: the one file
+      # the schema is read from, importing the others (`#import user.graphql`,
+      # `#import blog/*.graphql`; see SchemaStitcher). RAILS_ROOT/graphql/schema.graphql
+      # by default.
+      def schema_path
+        @schema_path ||= (::Rails.root.join('graphql/schema.graphql').to_s if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root)
+      end
+
+      # The folder of the schema's entrypoint, which watch_sdl watches.
+      def schema_directory
+        schema_path && File.dirname(schema_path.to_s)
+      end
+
+      # Rewrite the IDE helper files (schema-directives.graphql,
+      # programmatic-types.graphql) on boot and on every reload. nil (the
+      # default): in development, when the app has a graphql.config.yml.
+      def ide_helper
+        return @ide_helper unless @ide_helper.nil?
 
-      def sdl_folder
-        @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.join('graphql').to_s : nil)
+        defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env.development? && ::Rails.root &&
+          File.exist?(::Rails.root.join('graphql.config.yml'))
       end
 
       def directive_map = @directive_map ||= {}
@@ -66,16 +83,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 +98,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 +117,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/contracts/arg_manipulator.rb

@@ -2,12 +2,16 @@
 
 require_relative 'directive'
 
-# A directive on a field ARGUMENT that mutates the schema AST before build,
-# e.g. @whereConditions / @whereHasConditions generating input/enum types and
-# swapping the `_` placeholder argument type.
+# A directive on a field ARGUMENT that rewrites the schema before it is built,
+# as PHP Lighthouse's ArgManipulator: @whereConditions, @whereHasConditions and
+# @orderBy generate the input types of an argument written with the `_`
+# placeholder, and type it with them.
 #
-# Implementors provide (at the class level)
-# `manipulate_argument_definition(manipulation_context, parent, field, arg, directive)`.
+# Implementors, built with (arg_node, directive_node), provide
+# `#manipulate_arg_definition(document_ast, field_node, type_node)` returning
+# the argument node (graphql-ruby's nodes are immutable: `arg.merge(type: ...)`).
+# New types go in the Lighthouse::GraphQL::DocumentAST (`define_type`).
+# ASTBuilder calls it for every argument of an object or interface field.
 module Lighthouse::Contracts::ArgManipulator
   include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/field_builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'directive'
+
+# A directive on a FIELD that constrains the query of the field's resolver
+# whatever the client sends, e.g. @orderBy(column:, direction:) on a field.
+# Applied after the argument builders, as PHP Lighthouse's FieldBuilderDirective.
+#
+# Implementors, built with (field_node, directive_node), provide
+# `#handle_field_builder(relation)` returning a relation.
+module Lighthouse::Contracts::FieldBuilder
+  include Lighthouse::Contracts::Directive
+end

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

@@ -25,13 +25,12 @@ class Lighthouse::GraphQL::DirectiveResolvers::AggregateDirectiveResolver < Ligh
     column_name = extract_directive_arg('column')
     function_name = extract_directive_arg('function')
     resolver_instance = self
-    field_ast_node = @field_def.ast_node
 
     install(target_type_class, lambda do |obj, args, ctx|
       relation = resolver_instance.send(:aggregate_source, obj, model_name, relation_name)
       return nil unless relation
 
-      relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args, ctx, resolver_instance)
+      relation = resolver_instance.apply_where_filters(relation, args, ctx)
       resolver_instance.send(:compute_aggregation, relation, column_name, function_name)
     end)
   end

data/lib/lighthouse/directive_resolvers/all_resolver.rb

@@ -25,8 +25,6 @@ class Lighthouse::GraphQL::DirectiveResolvers::AllDirectiveResolver < Lighthouse
     args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
     relation = apply_scopes(model_class.all)
 
-    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, @field_def.ast_node, args, ctx, self)
-
     relation = apply_where_filters(relation, args, ctx)
     relation = relation.limit(args[:first]) if args[:first]
     relation = relation.offset(args[:offset]) if args[:offset]

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

@@ -36,7 +36,7 @@ module Lighthouse::GraphQL::DirectiveResolvers
       return nil unless obj.respond_to?(name)
 
       return paginate(obj, name, args, ctx) if pagination_type
-      return constrained(association_scope(obj, name), args) if constrained?(args)
+      return constrained(association_scope(obj, name), args, ctx) if constrained?(args)
 
       dataloader = Lighthouse::Support::Batching.dataloader(ctx)
       return obj.public_send(name) unless dataloader && obj.class.respond_to?(:reflect_on_association)
@@ -52,11 +52,14 @@ module Lighthouse::GraphQL::DirectiveResolvers
       self.class.collection? && directive_arg('type')&.to_s&.upcase
     end
 
-    # Scopes or a supplied argument with a filter directive need a query of
-    # their own instead of the batched load.
+    # Scopes, a query directive on the field (@builder, @orderBy(column:)) or a
+    # supplied argument with a filter directive need a query of their own
+    # instead of the batched load.
     def constrained?(args)
-      return true if directive_arg('scopes')
+      directive_arg('scopes') || Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.any?(@field_def.ast_node) || filtered?(args)
+    end
 
+    def filtered?(args)
       registry = Lighthouse::DirectiveRegistry.default
       (@field_def.ast_node&.arguments || []).any? do |argument|
         args.key?(argument.name.underscore.to_sym) && argument.directives.any? { |d| filter_directive?(registry, d) }
@@ -68,8 +71,8 @@ module Lighthouse::GraphQL::DirectiveResolvers
       registry.arg_builder_class(directive.name) || CONDITION_DIRECTIVES.include?(directive.name)
     end
 
-    def constrained(relation, args)
-      relation = apply_where_filters(scoped(relation), args)
+    def constrained(relation, args, ctx)
+      relation = apply_where_filters(scoped(relation), args, ctx)
       self.class.collection? ? relation : relation.first
     end
 

data/lib/lighthouse/directive_resolvers/base.rb

@@ -18,12 +18,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
 
     args_h = args.respond_to?(:to_h) ? args.to_h : (args || {})
 
-    relation = apply_where_conditions(relation, args_h)
-    @field_def.ast_node.arguments.each do |arg_node|
-      relation = apply_where_has_conditions(relation, arg_node, args_h)
-    end
-
-    apply_arg_builders(relation, args_h, ctx)
+    apply_field_builders(apply_arg_builders(relation, args_h, ctx), args_h, ctx)
   rescue ::GraphQL::ExecutionError
     raise
   rescue StandardError => e
@@ -32,7 +27,7 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
   end
 
   # Compose argument-builder directives (@eq, @neq, @in, @notIn, @like,
-  # @where, @orderBy) onto the relation, in SDL argument order, for each
+  # @where, @orderBy, @whereConditions, @whereHasConditions) onto the relation, in SDL argument order, for each
   # field argument that carries one and that the client supplied a value
   # for — and for the input fields of an argument carrying @nest.
   def apply_arg_builders(relation, args_h, ctx = nil)
@@ -51,18 +46,6 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
     relation
   end
 
-  def extract_relation_name_from_directive(arg_node)
-    directive = arg_node.directives.find { |dir| dir.name == 'whereHasConditions' }
-    return nil unless directive
-
-    relation_arg = directive.arguments.find { |arg| arg.name == 'relation' }
-    return nil unless relation_arg
-
-    relation_arg.value.respond_to?(:value) ? relation_arg.value.value : relation_arg.value
-  rescue StandardError
-    nil
-  end
-
   def constantize_model(name)
     Lighthouse::Support::ModelResolver.constantize(name)
   end
@@ -113,24 +96,10 @@ class Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
     @field_def.type.unwrap.graphql_name.sub(/(SimplePaginator|Paginator|Connection)\z/, '')
   end
 
-  # The `where:` argument (@whereConditions), when the client supplied one.
-  def apply_where_conditions(relation, args_h)
-    where_condition = args_h[:where] || args_h['where']
-    return relation unless where_condition
-
-    Lighthouse::GraphQL::DirectiveResolvers::WhereConditionsApplier.apply(relation, where_condition)
-  end
-
-  # A `whereHasConditions` argument the client supplied filters the
-  # relation by the related records matching its condition.
-  def apply_where_has_conditions(relation, arg_node, args_h)
-    return relation unless arg_node.directives.any? { |dir| dir.name == 'whereHasConditions' }
-
-    arg_value = Lighthouse::Support::Naming.fetch_arg(args_h, arg_node.name)
-    return relation unless arg_value
-
-    relation_name = extract_relation_name_from_directive(arg_node) || Lighthouse::Support::Naming.derive_relation_name(arg_node.name)
-    Lighthouse::GraphQL::DirectiveResolvers::WhereConditionsApplier.apply_has_argument(relation, arg_node.name, arg_value, relation_name)
+  # The field's own query directives (@builder, @whereAuth, @orderBy(column:)),
+  # in SDL order, after the arguments', as PHP Lighthouse's enhanceBuilder applies them.
+  def apply_field_builders(relation, args_h = {}, ctx = nil)
+    Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, @field_def.ast_node, args_h, ctx, self)
   end
 
   # Every (argument, directive, builder class) on the field, in SDL order.