@adonis-agora/authkit-server 0.63.0 → 0.64.0

package/build/src/adapters/factory.d.ts

@@ -4,6 +4,24 @@ export type OidcAdapterClass = new (name: string) => OidcAdapter;
 export interface AdapterFactory {
     resolver(app: ApplicationService): Promise<OidcAdapterClass>;
 }
+/**
+ * Modelos do oidc-provider de vida curta, amarrados ao ciclo da sessão de
+ * login (nomes exatos que o provider passa ao adapter). Perder qualquer um
+ * deles custa no máximo um relogin — nunca um outage — então são os
+ * candidatos ao adapter da `session:` (Redis). Todo modelo fora daqui
+ * (`Client` em particular — sem ele nem a tela de login abre) fica no
+ * adapter default (durável).
+ */
+export declare const SESSION_SCOPED_MODELS: ReadonlySet<string>;
+/**
+ * Escolhe a classe de adapter pro nome do modelo: session-scoped vai pra
+ * `sessionClass`, o resto pra `defaultClass`. Pura (sem I/O) de propósito —
+ * o dispatcher do provider (`build_provider.ts`) e os serviços que instanciam
+ * adapter na mão (`AdminSessionsService`, account API) usam a MESMA regra.
+ * Sem `session.adapter` configurado as duas classes são a mesma (back-compat:
+ * tudo continua onde está hoje).
+ */
+export declare function pickModelAdapterClass(model: string, defaultClass: OidcAdapterClass, sessionClass: OidcAdapterClass): OidcAdapterClass;
 export interface RedisAdapterConfig {
     /** nome da conexão do @adonisjs/redis */
     connection: string;

package/build/src/adapters/factory.js

@@ -1,5 +1,40 @@
 import { DatabaseAdapter } from './database_adapter.js';
 import { RedisAdapter } from './redis_adapter.js';
+/**
+ * Modelos do oidc-provider de vida curta, amarrados ao ciclo da sessão de
+ * login (nomes exatos que o provider passa ao adapter). Perder qualquer um
+ * deles custa no máximo um relogin — nunca um outage — então são os
+ * candidatos ao adapter da `session:` (Redis). Todo modelo fora daqui
+ * (`Client` em particular — sem ele nem a tela de login abre) fica no
+ * adapter default (durável).
+ */
+export const SESSION_SCOPED_MODELS = new Set([
+    'Session',
+    'Interaction',
+    'Grant',
+    'AccessToken',
+    'RefreshToken',
+    'AuthorizationCode',
+    'DeviceCode',
+    'PushedAuthorizationRequest',
+    'BackchannelAuthenticationRequest',
+    'ClientCredentials',
+    'ReplayDetection',
+    // `RegistrationAccessToken`/`InitialAccessToken` ficam FORA de propósito:
+    // gerenciam o `Client` (rotação/reconfiguração) e precisam morar junto dele
+    // no backend durável — senão um flush do Redis orfana o gerenciamento.
+]);
+/**
+ * Escolhe a classe de adapter pro nome do modelo: session-scoped vai pra
+ * `sessionClass`, o resto pra `defaultClass`. Pura (sem I/O) de propósito —
+ * o dispatcher do provider (`build_provider.ts`) e os serviços que instanciam
+ * adapter na mão (`AdminSessionsService`, account API) usam a MESMA regra.
+ * Sem `session.adapter` configurado as duas classes são a mesma (back-compat:
+ * tudo continua onde está hoje).
+ */
+export function pickModelAdapterClass(model, defaultClass, sessionClass) {
+    return SESSION_SCOPED_MODELS.has(model) ? sessionClass : defaultClass;
+}
 export const adapters = {
     /**
      * Factory para o adapter Redis. O consumidor precisa ter o @adonisjs/redis

package/build/src/define_config.d.ts

@@ -706,6 +706,30 @@ export interface ResolvedInteractionRecoveryConfig {
 export interface AuthServerConfigInput {
     issuer: string;
     adapter: AdapterFactory;
+    /**
+     * Override do adapter pros modelos de vida curta (sessão e órbita dela —
+     * ver `SESSION_SCOPED_MODELS` em `adapters/factory.ts`). O `adapter` de cima
+     * continua sendo o default de TUDO (back-compat: sem `session`, nada muda);
+     * com `session.adapter`, os modelos session-scoped passam a usar ele e o
+     * resto (`Client` em particular) fica no `adapter`.
+     *
+     * O split recomendado: sessão no Redis (efêmero, TTL nativo, mesmo destino
+     * da sessão do app) e o resto no banco (durável — sem o `Client` nem a tela
+     * de login abre). Mesma connection Redis pros dois níveis de sessão é a
+     * recomendação (prefixos já namespaciam; destinos diferentes criam
+     * meio-logado e dois domínios de falha no logout), mas a lib não trava isso.
+     *
+     * ```ts
+     * defineConfig({
+     *   adapter: adapters.database({ connection: 'auth' }),
+     *   session: { adapter: adapters.redis({ connection: 'main' }) },
+     *   // ...
+     * })
+     * ```
+     */
+    session?: {
+        adapter?: AdapterFactory;
+    };
     /**
      * Clientes OIDC pré-carregados no provider ao subir. Útil para testes e
      * migrações pontuais. Para uso em produção, gerencie clients via console admin
@@ -1041,6 +1065,11 @@ export interface AuthServerConfigInput {
 export interface ResolvedServerConfig {
     issuer: string;
     AdapterClass: OidcAdapterClass;
+    /**
+     * Adapter dos modelos session-scoped (`SESSION_SCOPED_MODELS`). Sem
+     * `session.adapter` no input é a MESMA classe do `AdapterClass`.
+     */
+    SessionAdapterClass: OidcAdapterClass;
     clients: ClientConfig[];
     jwks: {
         keys: Record<string, any>[];

package/build/src/define_config.js

@@ -243,6 +243,11 @@ export function jwksAutoFallbackWarning(storePath) {
 export function defineConfig(config) {
     return configProvider.create(async (app) => {
         const AdapterClass = await config.adapter.resolver(app);
+        // `session.adapter` ausente ⇒ mesma classe do default (back-compat: o
+        // dispatcher vira identidade e tudo continua no adapter único de hoje).
+        const SessionAdapterClass = config.session?.adapter
+            ? await config.session.adapter.resolver(app)
+            : AdapterClass;
         // `jwks: 'auto'` → resolve env-aware: AUTHKIT_JWKS inline, senão managed em arquivo.
         const jwksConfig = config.jwks === 'auto'
             ? process.env.AUTHKIT_JWKS
@@ -323,6 +328,7 @@ export function defineConfig(config) {
         return {
             issuer: config.issuer,
             AdapterClass,
+            SessionAdapterClass,
             clients: config.clients ?? [],
             jwks: jwks,
             jwksConfig,

package/build/src/host/account_api/account_api_controller.js

@@ -495,9 +495,10 @@ export default class AccountApiController {
         if (!target) {
             return ctx.response.notFound(apiErr('not_found', 'Session not found.'));
         }
-        // Revoga via adapter diretamente.
-        const AdapterClass = service.config.AdapterClass;
-        const sessionAdapter = new AdapterClass('Session');
+        // Revoga via adapter diretamente (o da sessão — `Session` é
+        // session-scoped e pode viver em backend distinto do default).
+        const SessionAdapterClass = service.config.SessionAdapterClass ?? service.config.AdapterClass;
+        const sessionAdapter = new SessionAdapterClass('Session');
         await sessionAdapter.destroy(sessionId);
         await cfg.audit?.record({
             type: 'session.revoked',

package/build/src/host/admin_clients_service.js

@@ -19,8 +19,9 @@ export class AdminClientsService {
     #adapter;
     constructor(oidc) {
         this.oidc = oidc;
-        // O AdapterClass é o MESMO que o provider usa; instanciamos o model 'Client'
-        // para ler/gravar os mesmos artefatos que o oidc-provider persiste.
+        // `Client` NÃO é session-scoped: fica sempre no `AdapterClass` (default),
+        // os mesmos artefatos que o oidc-provider persiste — mesmo com `session:`
+        // configurado, clients continuam no backend durável.
         this.#adapter = new oidc.config.AdapterClass('Client');
     }
     /** Indica se o adapter suporta enumeração (capacidade opcional). */

package/build/src/host/admin_sessions_service.js

@@ -1,8 +1,10 @@
 import { getBootedApp } from '../../services/booted_app.js';
+import { pickModelAdapterClass } from '../adapters/factory.js';
 /**
- * Serviço de inspeção/revogação das SESSÕES e GRANTS ativos de uma conta,
- * persistidos pelo oidc-provider via o MESMO `AdapterClass` (mesmo padrão do
- * {@link AdminClientsService}). Encapsula:
+ * Serviço de inspeção/revogação das SESSÕES e GRANTS ativos de uma conta.
+ * Lê/escreve via `pickModelAdapterClass` (a MESMA regra do provider): com
+ * `session:` configurado, Session/Grant/tokens saem do adapter da sessão, não
+ * do default. Encapsula:
  *   - a enumeração via a capacidade opcional `list` do adapter (degrada quando
  *     ausente, igual ao CRUD de clients);
  *   - a destruição das sessões + grants da conta. Destruir um grant CASCATEIA a
@@ -16,16 +18,21 @@ import { getBootedApp } from '../../services/booted_app.js';
 const GLOBAL_SESSION_LIMIT = 500;
 export class AdminSessionsService {
     #AdapterClass;
+    #SessionAdapterClass;
     #accountStore;
     /** Conexão Lucid das tabelas authkit (schema `auth`) — onde vive auth_session_revocations. */
     #schemaConnection;
     constructor(oidc) {
         this.#AdapterClass = oidc.config.AdapterClass;
+        // `Session`/`Grant`/tokens vivem no adapter da sessão quando `session:`
+        // está configurado (default: o mesmo do `AdapterClass`). `??` cobre
+        // configs resolvidas por versões antigas do `defineConfig`.
+        this.#SessionAdapterClass = oidc.config.SessionAdapterClass ?? oidc.config.AdapterClass;
         this.#accountStore = oidc.config.accountStore;
         this.#schemaConnection = oidc.config.schema?.connection;
     }
     #adapter(model) {
-        return new this.#AdapterClass(model);
+        return new (pickModelAdapterClass(model, this.#AdapterClass, this.#SessionAdapterClass))(model);
     }
     /**
      * Grava uma revogação por `sub` na tabela compartilhada `auth_session_revocations`,

package/build/src/provider/build_provider.js

@@ -1,4 +1,5 @@
 import * as oidc from 'oidc-provider';
+import { pickModelAdapterClass } from '../adapters/factory.js';
 import { createDeviceSources } from './device_sources.js';
 import { createLogoutSources } from './logout_sources.js';
 /** Atualiza o holder mutável do TTL de sessão com os valores da setting. */
@@ -92,7 +93,12 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
         }
         : {};
     const provider = new oidc.Provider(config.issuer, {
-        adapter: config.AdapterClass,
+        // Dispatcher por modelo (suportado pelo oidc-provider: `Adapter` aceita
+        // função `(name) => adapter` além de classe). Session-scoped vai pro
+        // `SessionAdapterClass`, o resto pro `AdapterClass` — mesma regra de
+        // `pickModelAdapterClass`, usada também pelos serviços que instanciam
+        // adapter na mão. Sem `session.adapter`, as duas classes são a mesma.
+        adapter: ((name) => new (pickModelAdapterClass(name, config.AdapterClass, config.SessionAdapterClass))(name)),
         clients: config.clients.map((c) => ({
             client_id: c.clientId,
             client_secret: c.clientSecret,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",