lighthouse-graphql 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44b6e89e140483d01ad4cb9c945cfc29d6f025e05798ed4e5e11868060b86885
-  data.tar.gz: cac88d1820f171e4cbe6dfaa51b737c405cacf6ec3c08ed4ce8694eb2039aa18
+  metadata.gz: 5dd6b5839f6520df6489135c1a37382ce4f7889d136140f652443ad5a3cd1a81
+  data.tar.gz: 60fdb10b55abe72a1dc3df89705b904b424344e5bffa611e695a46fa8767ddc7
 SHA512:
-  metadata.gz: b70da4e82689cc2808b00c514f4de0eafb60fedcff45d6f0fa28b560bc3dbe502e6d3b4c0a7615d33065f95fa82fc756332added5dd9f2ba9396ef6b38ff79ce
-  data.tar.gz: 8a30bc33a00599f3302196e3e24c881be56a68f94026ae1c0ab64246afa7b2114f6e723fba4f203fe51be03661bc6351f65fc12e3d4827624a6e04a2798b53fd
+  metadata.gz: 0f2aff4008f41238a6ebca9c598add10069e7f0c4c8c5578bc1041f3da50f36b859b9ce1c91a29576442562a42afca20845b8fb3704b19d374570381a3588262
+  data.tar.gz: b985fc24dfb2d0196c96f84cb0423d0b21e38659a0bc1cd4db13dc3818a8939fd2340006d85605cb5a50fde37f638d177ba90bf5af26e2cc3b9a3a0c2043986a

data/CHANGELOG.md

@@ -6,6 +6,185 @@ project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-18
+
+### Added
+
+- `Lighthouse::GraphQL::Type`, a concern that hands a graphql-ruby type class to Lighthouse, in
+  graphql-ruby's `app/graphql/types` structure. A field of an object type with no resolving
+  directive resolves with the method of its snake_case name on `Types::<Type>Type`, when that class
+  includes the concern and defines it (`Post.readingTime` → `Types::PostType#reading_time`). As in
+  graphql-ruby, the method has `object` (the parent), `context`, the `dataload*` helpers, and the
+  field's arguments as keywords. The SDL still declares the fields; the ones the class does not
+  define are read off the object as before. A type class that does not include the concern is left
+  alone. The class is looked up in the new `types` namespace (default `['Types']`), and must inherit
+  from `base_types[:object]` when one is given.
+- `@model(class:)`, as PHP Lighthouse's: maps an object type to the ActiveRecord model of another
+  name. Every directive taking `model:` (`@all`, `@find`, `@paginate`, `@create`, `@update`, the
+  `@can*` family...) on a field returning the type gets it, unless it names its own; unions,
+  interfaces and `@node` resolve the model's records to the type; the schema does not build unless
+  it is a model; and a type class's methods only run on its records (another parent is reported
+  through `on_error`).
+- Unions and interfaces resolve each value to its object type as PHP Lighthouse does: a Hash's
+  `__typename`, else the type named after the value's class or a superclass (STI), else the type
+  whose `@model` names its model. A union's type class (`Types::SearchResultType` including the
+  concern) can take over with graphql-ruby's `self.resolve_type(object, context)`, an interface's
+  with `definition_methods { def resolve_type }`, and `@union(resolveType:)` /
+  `@interface(resolveType:)` name a class in the SDL. A value nothing resolves, or one resolved
+  outside the union, raises `Lighthouse::DefinitionError` naming the ways out.
+- Custom scalars read and write their values through their class: `Types::DateTimeType` (a
+  `GraphQL::Schema::Scalar` including the concern), or the class `@scalar(class:)` names, with
+  graphql-ruby's `coerce_input` / `coerce_result`. A `GraphQL::CoercionError` makes the argument
+  invalid with its message. A scalar with no class passes its values through, as before.
+- `@method` passes the field's arguments to the method: as snake_case keywords when it takes
+  keywords, otherwise positionally in SDL order, as PHP Lighthouse does.
+- `base_types[:union]`, `[:interface]` and `[:scalar]`, like `[:object]`, are the bases the type
+  classes of their kind must inherit from.
+- `docs/types.md`: unions, interfaces and scalars.
+- `@field(resolver: "Class@method")`, as PHP Lighthouse's: the method replaces `call` on a plain
+  class (as a class method, else an instance method), or `resolve` on a resolver class, whose
+  `ready?` / `authorized?` still run.
+- `ResolveInfo`, PHP Lighthouse's `$resolveInfo`: `resolve_info` in `Resolvers::` / `Mutations::`
+  classes, classes `@field` names and type class methods, and a fourth argument for a plain callable
+  that takes one. It has the field, its parent type, object, arguments, context and path, and
+  `enhance_builder(relation, scopes: [])`, which applies the field's `@builder` classes and argument
+  directives (`@eq`, `@where`, `@orderBy`, `@whereConditions`, ...) to a query the class builds.
+- `@with(relation:, scopes:)` and `@withCount(relation:, scopes:)` eager-load a relation, or its
+  count (kept on the parent as `<relation>_count`), before the field resolves; `@lazyLoad(relations:)`
+  eager-loads relations of the records a field returns. All three load across every parent in the
+  response at once, through the Dataloader, and take nested relations (`"posts.comments"`).
+- Relay global object identification: `@globalId` encodes a field (base64 of `Type:id`) and decodes
+  an argument or input field (`decode: ARRAY | TYPE | ID`); `@node` makes a type implement `Node` and
+  adds `Query.node(id:)`, which finds the record through the type's model or `@node(resolver:)`. The
+  new `global_id` setting takes your own encoder. `docs/relay.md`.
+- A union's or interface's class may answer `[type, value]`, as graphql-ruby allows.
+- File uploads: the `Upload` scalar (Lighthouse's own for `scalar Upload`), the GraphQL multipart
+  request specification in `Lighthouse::GraphQL::Controller`, and `@upload(disk:, path:)`, which
+  stores the file through the new `upload_store` setting (an ActiveStorage blob by default) and
+  passes its signed id. `docs/uploads.md`.
+- Filters: `@whereNull`, `@whereNotNull`, `@whereBetween`, `@whereNotBetween`, `@whereJsonContains`
+  (PostgreSQL, MySQL, SQLite), `@scope`, `@nest` (the filters of an input's fields) and `@limit`
+  (a LIMIT, or a per-parent cut of a relation's records); `@whereAuth(relation:)` keeps the
+  signed-in user's records.
+- Argument directives: `@trim`, `@drop`, `@hash` (BCrypt) and `@bind(class:)`, which replaces an id
+  with its record(s) or fails validation. Rewriting ones (`@globalId`, `@trim`, `@drop`) run before
+  `@guard`, `@can*` and `@validator`; effectful ones (`@hash`, `@bind`, `@upload`) after them.
+- `@builder` on an argument or input field, as PHP Lighthouse's: the method gets the argument's
+  value whenever the client sends it, `null` included. `method: "Class@method"` names the builder
+  without `class:`, and `value:` on a field passes a fixed value in place of the arguments.
+- `@limit(builder: true)` puts the LIMIT on the field's query; `@limit` must be on an `Int` argument,
+  and is accepted on the field itself, as PHP Lighthouse allows.
+- `@hasManyThrough` and `@hasOneThrough`, PHP Lighthouse's names, as aliases of `@hasMany` and
+  `@hasOne`, which resolve `has_many` / `has_one :through`.
+- `ResolveInfo#lookahead`: graphql-ruby's Lookahead for a field resolved by a class (a `Resolvers::`
+  class, `@field`, a type class method). It never reaches the arguments, so `@cache` keys are unchanged.
+- `@throttle` logs a warning when the cache store is a `:null_store`, which counts nothing.
+- `@enum(value:)` for an enum value's internal value; `@namespaced` to group fields; `@throttle` to
+  rate-limit a field per user or IP (the controller concern now puts `:remote_ip` in the context);
+  `@async` to run a mutation in an ActiveJob and answer `true`; `@hide(env:)` / `@show(env:)` to leave
+  fields out by environment (the schema cache key now includes it).
+
+### Changed
+
+- Generators build on graphql-ruby's instead of copying them. `lighthouse:install` runs
+  `graphql:install --no-relay --skip-graphiql --skip-query-logs` for the base classes every
+  graphql-ruby app has (`Types::Base*`, `Resolvers::BaseResolver`, `Mutations::BaseMutation`), then
+  replaces what it wrote that an SDL-first app does differently: the schema class (built from the
+  SDL, naming every base in `base_types`), the controller, no `Types::QueryType` /
+  `MutationType`, and a `BaseMutation` that is a `GraphQL::Schema::Mutation`. It writes
+  `Subscriptions::BaseSubscription` itself, graphql-ruby having none. Files the app had are kept.
+- `docs/generators.md`: every generator, and which of graphql-ruby's fit a Lighthouse app
+  (`graphql:object`, `:scalar`, `:union`, `:interface` for type classes; `graphql:mutation` and
+  `graphql:detailed_trace` not as they are).
+
+- `@field(resolver:)` on a field of a type other than `Query` and `Mutation` looks the class up in
+  the resolvers namespace first, nested names included: `@field(resolver: "Posts::TagsCount")`
+  resolves to `Resolvers::Posts::TagsCount`. Then it tries `resolver_namespaces`, as before, so
+  full names and classes outside `Resolvers::` resolve as they did. A class `Resolvers::X` now
+  wins over one that `resolver_namespaces` would find for the same name.
+
+### Fixed
+
+- A wrapping directive (`@globalId`, `@guard`, `@cache`, ...) on a field of a type whose objects are
+  Hashes read nothing: the wrapped default reader only called methods. It now reads the Hash's
+  keys, as the default reader does.
+
+- A field returning a union or an interface no longer raises `undefined method 'resolve_type' for
+  an instance of Proc`. Lighthouse's field dispatcher replaced the schema's default resolve with a
+  Proc, which graphql-ruby also asks for `resolve_type` and scalar coercion; it now hands both on.
+
+- `@field(resolver:)` on a `Query` or `Mutation` field finds a nested name in the resolvers /
+  mutations namespaces, as documented: `"Feeds::Home"` resolves to `Resolvers::Feeds::Home`,
+  then to `Feeds::Home`. It used to try only `Feeds::Home`, so the field resolved to `null`.
+  The field's `complexity` is looked up the same way.
+
+### Documentation
+
+- `docs/resolvers.md`: fields of types other than `Query` and `Mutation` resolved with `@field`,
+  whose class receives the parent record as `object`. The example app resolves `Post.tagsCount`
+  (batched through the dataloader), `Post.excerpt(length:)` and `Query.popularTags` this way.
+  It resolves `Post.readingTime` and the `ReadingTime` type, which is not a model, with
+  `Types::PostType` and `Types::ReadingTimeType`, `Query.search` (a union of `Post` and `User`)
+  and `Query.latestActivity` (an `Authored` interface) by the default, `DateTime` with
+  `Types::DateTimeType`, and `Post.summary(words:)` with `@method`. `Tag` is a Relay node with
+  global ids; `User.latestPostTitle` uses `@with`, `Tag.usage` `@withCount`, `User.posts`
+  `@lazyLoad`, `Query.counts` `@field(resolver: "Statistics@counts")`, and `Query.myPosts`
+  `resolve_info.enhance_builder`. `Mutation.updateAvatar` takes a multipart upload with `@upload`
+  (the example now loads ActiveStorage). `Mutation.schedulePublish` is `@async` on Solid Queue,
+  `Query.searchPosts` is `@throttle`d, and `Query.posts` filters `metadata` with `@whereJsonContains`;
+  the example's suite runs on PostgreSQL and MySQL too (`DATABASE_URL`, a new CI job), with Redis.
+
+### Removed
+
+- `rails g lighthouse:type`: it was graphql-ruby's `graphql:object` (and `:scalar`, `:union`,
+  `:interface`) with an `include`. Generate the class with graphql-ruby, then add
+  `include Lighthouse::GraphQL::Type`.
+- `lighthouse:query` and `lighthouse:mutation` no longer write `Resolvers::BaseResolver` /
+  `Mutations::BaseMutation` when they are missing: graphql-ruby's install writes them, which
+  `lighthouse:install` runs. They say so instead.
+
+## [0.4.0] - 2026-10-17
+
+### Added
+
+- `@complexity` sets what a field costs in graphql-ruby's query complexity analysis, so
+  `AppSchema.max_complexity(n)` refuses expensive queries before they run. A bare `@complexity`
+  costs `1 + child complexity × first`. `@complexity(resolver: "Name")` names a
+  `GraphQL::Analysis::Analyzer` subclass in the new `analyzers` namespace (`Analyzers::Name`),
+  which Lighthouse installs on the schema. Including `Lighthouse::GraphQL::ComplexityAnalyzer`
+  gives the analyzer a `complexity` (a number, or a proc of `context, args, child_complexity`,
+  as graphql-ruby's) that is the cost of the fields naming it.
+- A root field resolved by a `GraphQL::Schema::Resolver` class, by convention or through `@field`,
+  takes the `complexity` that class declares, as graphql-ruby's `field ..., resolver:` does.
+- `BuildExtensionsResponse#query_complexity` holds the query's complexity score while something
+  listens to the event. It used to be `nil`.
+- `docs/security.md`: query complexity, depth and introspection limits.
+- graphql-ruby's base classes: `rails g lighthouse:install` writes `Resolvers::BaseResolver`,
+  `Mutations::BaseMutation` and `Subscriptions::BaseSubscription` (which includes
+  `Lighthouse::GraphQL::Subscription`), and `lighthouse:query`, `:mutation` and `:subscription`
+  write the one they need when it is missing. Generated classes inherit from them. An existing
+  base, such as the ones graphql-ruby's `graphql:install` writes, is never replaced.
+- `get_schema`'s `base_types` takes `resolver:`, `mutation:` and `subscription:` beside
+  graphql-ruby's own keys. Every class a `Query`, `Mutation` or `Subscription` field resolves to
+  must then inherit from its kind's base (`Lighthouse::DefinitionError` otherwise), and a
+  `Subscription` field with no class of its own resolves with the subscription base. The
+  generated schema class names the three.
+
+### Changed
+
+- The classes of `Query` fields are looked up in `Resolvers` (`app/graphql/resolvers`), graphql-ruby's
+  convention, instead of `Queries`: `Query.latestPosts` resolves to `Resolvers::LatestPosts`, and
+  `lighthouse:query` writes there. To keep `app/graphql/queries`, set
+  `config.namespaces = { queries: ['Queries'] }`.
+- `lighthouse:subscription` no longer takes `--lighthouse`. The class inherits from
+  `Subscriptions::BaseSubscription`, which includes the concern, and gets its hooks; under a base
+  without the concern, it gets graphql-ruby's `authorized?` and `update`.
+
+- Paginated fields (`@paginate`, and relationship directives given `type:`) cost
+  `1 + child complexity × first` in the complexity score. A page of 1,000 items now scores
+  1,000 times one item's cost; before, a paginator scored the same whatever `first` was.
+  A schema that already sets `max_complexity` may need a higher limit.
+
 ## [0.3.0] - 2026-10-17
 
 ### Added
@@ -282,7 +461,9 @@ had been running inside a private monorepo as a path gem before being extracted.
 - Config-driven extension seams: `Lighthouse.configure`, `resolver_namespaces`,
   `on_error`, and `DirectiveRegistry.register` for app-defined directives.
 
-[Unreleased]: https://github.com/Vaz-Innovation/lighthouse-graphql/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/Vaz-Innovation/lighthouse-graphql/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/Vaz-Innovation/lighthouse-graphql/compare/v0.4.0...v0.5.0
+[0.4.0]: https://github.com/Vaz-Innovation/lighthouse-graphql/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/Vaz-Innovation/lighthouse-graphql/compare/v0.2.1...v0.3.0
 [0.2.1]: https://github.com/Vaz-Innovation/lighthouse-graphql/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/Vaz-Innovation/lighthouse-graphql/compare/v0.1.1...v0.2.0

data/README.md

@@ -78,10 +78,13 @@ Then let the generator set the app up:
 bin/rails generate lighthouse:install
 ```
 
-It creates the initializer, a starter schema in `graphql/schema.graphql`, the
-`AppSchema` class, a `GraphqlController` with its `POST /graphql` route, and a
-`graphql.config.yml` for your IDE. Run `bin/rails generate lighthouse:install --help`
-for its options (`--schema`, `--sdl-folder`, `--skip-controller`, `--skip-ide`).
+It runs graphql-ruby's own `graphql:install` for the base classes every graphql-ruby
+app has, then writes Lighthouse's on top: the initializer, a starter schema in
+`graphql/schema.graphql`, the `AppSchema` class built from it, a `GraphqlController`
+with its `POST /graphql` route, and a `graphql.config.yml` for your IDE. Run
+`bin/rails generate lighthouse:install --help` for its options (`--schema`,
+`--sdl-folder`, `--skip-controller`, `--skip-ide`), and see
+[docs/generators.md](docs/generators.md) for every generator, graphql-ruby's included.
 
 ### IDE support
 
@@ -127,7 +130,14 @@ Prefer to wire it by hand? These are the steps the generator performs.
 
    AppSchema = Lighthouse::GraphQL::RbLightHouse.get_schema(
      sdl_folder: Rails.root.join('graphql').to_s,
-     options: { base_types: { object: BaseObject } } # your graphql-ruby base classes
+     options: {
+       base_types: {
+         resolver: Resolvers::BaseResolver,              # graphql-ruby's base classes, which
+         mutation: Mutations::BaseMutation,              # rails g lighthouse:install has graphql-ruby write
+         subscription: Subscriptions::BaseSubscription
+         # object: Types::BaseObject, ...
+       }
+     }
    )
    ```
 
@@ -143,7 +153,8 @@ including base types and configuration.
 ### Example app
 
 [`example/`](example) is a small blog API built with Lighthouse on Rails 8.1. It shows
-the schema, the generated `Queries::`/`Mutations::`/`Builders::`/`Validators::` classes,
+the schema, the generated `Resolvers::`/`Mutations::`/`Subscriptions::`/`Builders::`/`Validators::` classes
+under graphql-ruby's base classes,
 Pundit policies and the opt-in performance features working together, and its specs
 are the library's end-to-end suite. See [example/README.md](example/README.md).
 
@@ -161,7 +172,7 @@ or as Markdown in [`docs/`](docs):
 | [Directives reference](docs/directives.md) | Every built-in directive, grouped by purpose |
 | [Relationships](docs/relationships.md) | `@hasMany`, `@belongsTo`, `@belongsToMany`, `@hasOne`, the `@morph*` variants, batching and `type:` pagination |
 | [Filtering & ordering](docs/filtering-and-ordering.md) | `@eq`/`@where`/`@in`/`@like`, `@whereConditions`, `@orderBy` |
-| [Queries, mutations & builders](docs/resolvers.md) | `Queries::` / `Mutations::` classes (graphql-ruby's contract), builders, generators |
+| [Resolvers, mutations & builders](docs/resolvers.md) | `Resolvers::` / `Mutations::` classes and their base classes (graphql-ruby's contract), builders, generators |
 | [Mutations](docs/mutations.md) | `@create`, `@update`, `@upsert`, `@delete` (and `*Many`), nested mutations on every kind of association, `@spread`, `@inject` |
 | [Validation](docs/validation.md) | Model validations, `@validator` with Dry::Validation contracts |
 | [Authentication & authorization](docs/authorization.md) | `@guard`, `@canFind` / `@canModel` / `@canQuery` / `@canResolved` / `@canRoot` (Pundit by default) |

data/docs/best-practices.md

@@ -44,12 +44,22 @@ Use `@guard` and the `@can*` directives on fields that require them. They wrap t
 resolver, so the check runs before any data is loaded (only `@canResolved`, which
 needs the result, runs after — keep it to fields that don't write).
 
-## Keep queries, mutations and builders apart
-
-A custom `Query` field is a `GraphQL::Schema::Resolver` in `app/graphql/queries`,
-a `Mutation` field a `GraphQL::Schema::Mutation` in `app/graphql/mutations`, and a
-query refinement a builder in `app/graphql/builders`. They have different jobs and
-contracts; don't fold them into one "resolvers" folder. See [resolvers.md](resolvers.md).
+## Keep resolvers, mutations and builders apart
+
+A custom `Query` field is a `Resolvers::BaseResolver` in `app/graphql/resolvers`, a
+`Mutation` field a `Mutations::BaseMutation` in `app/graphql/mutations`, and a query
+refinement a builder in `app/graphql/builders`. They have different jobs and
+contracts; keep each kind in its own folder. See [resolvers.md](resolvers.md).
+
+## Share through the base classes
+
+What every resolver, mutation or subscription needs (a concern, a helper,
+graphql-ruby's `argument_class`) goes in `Resolvers::BaseResolver`,
+`Mutations::BaseMutation` or `Subscriptions::BaseSubscription`, once, as in any
+graphql-ruby app. Name them in the schema's `base_types` (`resolver:`, `mutation:`,
+`subscription:`), and a class that forgets to inherit from its base is refused
+instead of quietly missing what it shares. See
+[resolvers.md](resolvers.md#base-classes).
 
 ## Validate in the model first
 

data/docs/configuration.md

@@ -10,8 +10,8 @@ require 'lighthouse-graphql'
 
 Lighthouse.configure do |config|
   config.sdl_folder = Rails.root.join('graphql').to_s
-  config.namespaces = { queries: ['Queries'], mutations: ['Mutations'] }
-  config.resolver_namespaces = ['App::Graphql', 'Resolvers']
+  config.namespaces = { queries: ['Resolvers'], mutations: ['Mutations'] }
+  config.resolver_namespaces = ['App::Graphql']
   config.on_error = ->(error, _context) { Rails.error.report(error) }
 end
 ```
@@ -31,23 +31,26 @@ different contracts, so they live apart ([resolvers.md](resolvers.md)):
 
 | Kind | Default | Holds |
 | --- | --- | --- |
-| `queries` | `['Queries']` | `GraphQL::Schema::Resolver` classes for `Query` fields |
-| `mutations` | `['Mutations']` | `GraphQL::Schema::Mutation` classes for `Mutation` fields |
+| `queries` | `['Resolvers']` | `Resolvers::BaseResolver` classes (a `GraphQL::Schema::Resolver`) for `Query` fields. `['Queries']` before 0.4.0 |
+| `mutations` | `['Mutations']` | `Mutations::BaseMutation` classes (a `GraphQL::Schema::Mutation`) for `Mutation` fields |
 | `builders` | `['Builders']` | `@builder` classes |
 | `validators` | `['Validators']` | `@validator` contracts |
 | `events` | `['Events']` | Classes `@event(dispatch:)` names ([events.md](events.md)) |
-| `subscriptions` | `['Subscriptions']` | `GraphQL::Schema::Subscription` classes (optionally including `Lighthouse::GraphQL::Subscription`) for `Subscription` fields, and `@subscription(class:)` ([subscriptions.md](subscriptions.md)) |
+| `subscriptions` | `['Subscriptions']` | `Subscriptions::BaseSubscription` classes (a `GraphQL::Schema::Subscription`; the base includes `Lighthouse::GraphQL::Subscription`) for `Subscription` fields, and `@subscription(class:)` ([subscriptions.md](subscriptions.md)) |
+| `analyzers` | `['Analyzers']` | `GraphQL::Analysis::Analyzer` classes (optionally including `Lighthouse::GraphQL::ComplexityAnalyzer`) that `@complexity(resolver:)` names ([security.md](security.md)) |
+| `types` | `['Types']` | `Types::<Name>Type` classes including `Lighthouse::GraphQL::Type`: an object type's, whose methods resolve the fields of the SDL type `<Name>` ([resolvers.md](resolvers.md#type-classes)); a union's or interface's, which picks its values' types; a scalar's, which coerces its values ([types.md](types.md)). Also where `@union`, `@interface` and `@scalar` look classes up |
 
 ```ruby
-config.namespaces = { queries: ['Api::Queries'] }   # the other kinds keep their defaults
+config.namespaces = { queries: ['Api::Resolvers'] }   # the other kinds keep their defaults
 ```
 
 ### `resolver_namespaces`
 
 An ordered list of namespaces tried for **models** named by a directive
 (`@all(model: "User")`) and for `@field(resolver:)` on types other than `Query`
-and `Mutation`. Fully-qualified names (containing `::`) are used as-is. Defaults
-to `['App::Graphql']`.
+and `Mutation`, after the resolvers namespace
+([resolvers.md](resolvers.md#fields-of-other-types)). Fully-qualified names
+(containing `::`) are used as-is. Defaults to `['App::Graphql']`.
 
 ```ruby
 config.resolver_namespaces = ['App::Graphql', 'Resolvers']
@@ -114,6 +117,28 @@ initializer.
 config.convert_empty_strings_to_null = true
 ```
 
+### `global_id`
+
+Encodes and decodes Relay global ids for [`@globalId` and `@node`](relay.md): any
+object with `encode(type, id)` returning the global id, and `decode(global_id)`
+returning `[type, id]`. Defaults to `Lighthouse::GraphQL::GlobalId`, the base64 of
+`Type:id`, as PHP Lighthouse's.
+
+```ruby
+config.global_id = SignedGlobalIds
+```
+
+### `upload_store`
+
+Stores the file an [`@upload`](uploads.md) argument carries: any object with
+`call(file, disk:, path:, public:)`, whose return value the argument then holds.
+Defaults to `Lighthouse::GraphQL::UploadStore`, which makes an ActiveStorage blob and
+returns its signed id.
+
+```ruby
+config.upload_store = ->(file, path: '/', **) { S3Uploader.put(file, prefix: path) }
+```
+
 ### `queue_broadcasts`, `broadcast_queue`
 
 Whether [`@broadcast`](directives.md#broadcast) triggers its subscription in an