@adonis-agora/authkit-client 0.9.0

package/build/src/register_oidc_client.js

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+import { buildAuthorizeUrl, buildEndSessionUrl, exchangeCode, generatePkce } from './oidc_login.js';
+/**
+ * Registra as rotas OIDC de CLIENT (login/callback/logout [+ back-channel logout])
+ * absorvendo o boilerplate que cada app reescrevia no OidcSessionController: PKCE +
+ * state na sessão, troca de code, validação, logout RP-initiated e redirect por papel.
+ *
+ * ```ts
+ * // start/routes.ts
+ * import { registerOidcClient } from '@adonis-agora/authkit-client'
+ * registerOidcClient(router, {
+ *   loginMiddleware: middleware.guest(),
+ *   redirects: { byGlobalRole: { ADMIN: '/admin' }, byAppRole: { ADVISOR: '/advisor' }, default: '/' },
+ * })
+ * ```
+ */
+export function registerOidcClient(router, options = {}) {
+    const prefix = options.prefix ?? '/auth';
+    const passthrough = options.passthroughParams ?? ['audience'];
+    const pkceKey = 'authkit_pkce';
+    const loginRoute = router.get(`${prefix}/login`, async (ctx) => {
+        const manager = await ctx.containerResolver.make('authkit.client');
+        const cfg = manager.clientConfig;
+        const { verifier, challenge } = await generatePkce();
+        const state = randomUUID();
+        ctx.session?.put(pkceKey, { verifier, state });
+        const extraParams = {};
+        for (const param of passthrough) {
+            const v = ctx.request.input(param);
+            if (v !== undefined && v !== null && v !== '')
+                extraParams[param] = String(v);
+        }
+        const url = buildAuthorizeUrl({
+            issuer: cfg.issuer,
+            clientId: cfg.clientId,
+            redirectUri: cfg.redirectUri,
+            scopes: cfg.scopes,
+            state,
+            codeChallenge: challenge,
+            ...(Object.keys(extraParams).length ? { extraParams } : {}),
+        });
+        return ctx.response.redirect(url);
+    });
+    if (options.loginMiddleware)
+        loginRoute.use(options.loginMiddleware);
+    loginRoute.as('auth.login');
+    router
+        .get(`${prefix}/callback`, async (ctx) => {
+        const manager = await ctx.containerResolver.make('authkit.client');
+        const cfg = manager.clientConfig;
+        const { code, state } = ctx.request.qs();
+        const pkce = ctx.session?.get(pkceKey);
+        // Callback velho/expirado (state perdido ou code ausente) → recomeça o login.
+        if (!pkce || pkce.state !== state || !code) {
+            ;
+            ctx.session?.forget(pkceKey);
+            return ctx.response.redirect(`${prefix}/login`);
+        }
+        const tokenSet = await exchangeCode({
+            issuer: cfg.issuer,
+            clientId: cfg.clientId,
+            clientSecret: cfg.clientSecret,
+            redirectUri: cfg.redirectUri,
+            code,
+            codeVerifier: pkce.verifier,
+        });
+        ctx.session?.put(cfg.sessionKey, tokenSet);
+        ctx.session?.forget(pkceKey);
+        const authenticator = await manager.createAuthenticator(ctx);
+        const identity = await authenticator.getIdentity();
+        // 1) Hook do app tem prioridade quando retorna uma rota.
+        const hook = await options.afterLogin?.(ctx, identity);
+        if (typeof hook === 'string')
+            return ctx.response.redirect(hook);
+        // 2) Redirect por papel: global primeiro, depois app.
+        const dest = await resolveDestination(authenticator, identity, options.redirects);
+        return ctx.response.redirect(dest);
+    })
+        .as('auth.callback');
+    router
+        .post(`${prefix}/logout`, async (ctx) => {
+        const manager = await ctx.containerResolver.make('authkit.client');
+        const cfg = manager.clientConfig;
+        const idToken = manager.getIdToken(ctx);
+        ctx.session?.forget(cfg.sessionKey);
+        const postLogoutRedirectUri = typeof options.postLogoutRedirect === 'function'
+            ? options.postLogoutRedirect(ctx)
+            : (options.postLogoutRedirect ?? new URL(cfg.redirectUri).origin + '/');
+        const endSessionUrl = buildEndSessionUrl({
+            issuer: cfg.issuer,
+            idToken,
+            postLogoutRedirectUri,
+            clientId: cfg.clientId,
+        });
+        return ctx.response.redirect(endSessionUrl);
+    })
+        .as('auth.logout');
+    if (options.backchannelLogout !== false) {
+        router
+            .post(`${prefix}/backchannel-logout`, async (ctx) => {
+            const manager = await ctx.containerResolver.make('authkit.client');
+            return manager.handleBackchannelLogout(ctx);
+        })
+            .as('auth.backchannel_logout');
+    }
+}
+/** Resolve o destino pós-login a partir do mapa de redirects por papel. */
+async function resolveDestination(authenticator, identity, redirects) {
+    if (!redirects)
+        return '/';
+    const globalRoles = identity?.globalRoles ?? [];
+    if (redirects.byGlobalRole) {
+        for (const [role, path] of Object.entries(redirects.byGlobalRole)) {
+            if (globalRoles.includes(role))
+                return path;
+        }
+    }
+    if (redirects.byAppRole) {
+        for (const [role, path] of Object.entries(redirects.byAppRole)) {
+            if (await authenticator.hasAppRole(role))
+                return path;
+        }
+    }
+    return redirects.default ?? '/';
+}

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

@@ -0,0 +1,41 @@
+import type { SessionResolver } from '@adonis-agora/authkit-core';
+import { type TokenSource } from '../token_source.js';
+export interface JwtResolverFactoryConfig {
+    tokenSource?: TokenSource;
+    /** jwks_uri explícito; se omitido, é `${issuer}/jwks` (rota padrão do oidc-provider) */
+    jwksUri?: string;
+}
+export interface PatResolverFactoryConfig {
+    introspectionUrl: string;
+    introspectionSecret: string;
+}
+export interface OpaqueResolverFactoryConfig {
+    /**
+     * De onde tirar o access token. `session` (default) introspecta o access token
+     * guardado no TokenSet; `bearer` introspecta o token do header Authorization (APIs).
+     */
+    tokenSource?: TokenSource;
+    /** Endpoint de introspection; default `${issuer}/token/introspection` (oidc-provider). */
+    introspectionUrl?: string;
+    /**
+     * TTL (ms) do cache de respostas `active:true`. Default 0 (revogação imediata).
+     * Suba para reduzir round-trips ao custo de imediatismo.
+     */
+    cacheTtlMs?: number;
+}
+/** Contexto que o provider passa ao resolver na resolução. */
+export interface ResolverContext {
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    sessionKey: string;
+    globalRolesClaim: string;
+}
+export interface ResolverFactory {
+    resolver(ctx: ResolverContext): Promise<SessionResolver>;
+}
+export declare const resolvers: {
+    jwt(config?: JwtResolverFactoryConfig): ResolverFactory;
+    pat(config: PatResolverFactoryConfig): ResolverFactory;
+    opaque(config?: OpaqueResolverFactoryConfig): ResolverFactory;
+};

package/build/src/resolvers/factory.js

@@ -0,0 +1,51 @@
+import { JwtResolver } from './jwt_resolver.js';
+import { PatResolver } from './pat_resolver.js';
+import { OpaqueResolver } from './opaque_resolver.js';
+import { getTokenFromSource } from '../token_source.js';
+export const resolvers = {
+    jwt(config = {}) {
+        const tokenSource = config.tokenSource ?? 'session';
+        return {
+            async resolver(rc) {
+                const jwksUri = config.jwksUri ?? `${rc.issuer}/jwks`;
+                return new JwtResolver({
+                    issuer: rc.issuer,
+                    jwksUri,
+                    audience: rc.clientId,
+                    globalRolesClaim: rc.globalRolesClaim,
+                    getToken: (httpCtx) => getTokenFromSource(httpCtx, tokenSource, rc.sessionKey),
+                });
+            },
+        };
+    },
+    pat(config) {
+        return {
+            async resolver(_rc) {
+                return new PatResolver({
+                    introspectionUrl: config.introspectionUrl,
+                    introspectionSecret: config.introspectionSecret,
+                });
+            },
+        };
+    },
+    opaque(config = {}) {
+        const tokenSource = config.tokenSource ?? 'session';
+        return {
+            async resolver(rc) {
+                if (!rc.clientSecret) {
+                    throw new Error('resolvers.opaque requer um client confidencial (clientSecret) para introspection');
+                }
+                const introspectionUrl = config.introspectionUrl ?? `${rc.issuer}/token/introspection`;
+                return new OpaqueResolver({
+                    introspectionUrl,
+                    clientId: rc.clientId,
+                    clientSecret: rc.clientSecret,
+                    tokenSource,
+                    sessionKey: rc.sessionKey,
+                    globalRolesClaim: rc.globalRolesClaim,
+                    cacheTtlMs: config.cacheTtlMs,
+                });
+            },
+        };
+    },
+};

package/build/src/resolvers/identity.d.ts

@@ -0,0 +1,30 @@
+import type { Identity } from '@adonis-agora/authkit-core';
+type FetchImpl = (url: string, init: any) => Promise<{
+    ok: boolean;
+    json: () => Promise<any>;
+}>;
+/**
+ * Mapeamento canônico de claims OIDC validadas → Identity, compartilhado pelos
+ * resolvers `jwt`, `pat` e `opaque`. Espelha exatamente o que o `JwtResolver`
+ * produzia (a referência canônica): `sub`→userId, `email`, papéis na
+ * `globalRolesClaim`, `name`/`picture`→profile, `sid`→sessionId, `iat`/`exp`
+ * (segundos→ms, fallback 0) e as claims cruas em `raw`.
+ */
+export declare function buildIdentityFromClaims(claims: Record<string, unknown>, globalRolesClaim: string): Identity;
+export interface IntrospectAuth {
+    /** `bearer` envia `Authorization: Bearer <value>`; `basic` envia `Authorization: Basic <value>`. */
+    type: 'bearer' | 'basic';
+    value: string;
+}
+export interface IntrospectOptions {
+    /** `token_type_hint` enviado no corpo (RFC 7662). */
+    tokenTypeHint?: string;
+    fetchImpl?: FetchImpl;
+}
+/**
+ * Introspecção de token padrão (RFC 7662): POST form-urlencoded com `token`
+ * (+ `token_type_hint` opcional) e autenticação Bearer ou Basic. Retorna o
+ * payload parseado quando `active:true`; caso contrário (ou em !res.ok) `null`.
+ */
+export declare function introspectToken(url: string, token: string, auth: IntrospectAuth, opts?: IntrospectOptions): Promise<Record<string, any> | null>;
+export {};

package/build/src/resolvers/identity.js

@@ -0,0 +1,49 @@
+/**
+ * Mapeamento canônico de claims OIDC validadas → Identity, compartilhado pelos
+ * resolvers `jwt`, `pat` e `opaque`. Espelha exatamente o que o `JwtResolver`
+ * produzia (a referência canônica): `sub`→userId, `email`, papéis na
+ * `globalRolesClaim`, `name`/`picture`→profile, `sid`→sessionId, `iat`/`exp`
+ * (segundos→ms, fallback 0) e as claims cruas em `raw`.
+ */
+export function buildIdentityFromClaims(claims, globalRolesClaim) {
+    const roles = claims[globalRolesClaim];
+    return {
+        userId: String(claims.sub ?? ''),
+        email: typeof claims.email === 'string' ? claims.email : '',
+        globalRoles: Array.isArray(roles) ? roles : [],
+        profile: {
+            name: typeof claims.name === 'string' ? claims.name : undefined,
+            avatarUrl: typeof claims.picture === 'string' ? claims.picture : undefined,
+        },
+        sessionId: typeof claims.sid === 'string' ? claims.sid : undefined,
+        issuedAt: typeof claims.iat === 'number' ? claims.iat * 1000 : 0,
+        expiresAt: typeof claims.exp === 'number' ? claims.exp * 1000 : 0,
+        raw: claims,
+    };
+}
+/**
+ * Introspecção de token padrão (RFC 7662): POST form-urlencoded com `token`
+ * (+ `token_type_hint` opcional) e autenticação Bearer ou Basic. Retorna o
+ * payload parseado quando `active:true`; caso contrário (ou em !res.ok) `null`.
+ */
+export async function introspectToken(url, token, auth, opts = {}) {
+    const doFetch = opts.fetchImpl ?? fetch;
+    const params = new URLSearchParams({ token });
+    if (opts.tokenTypeHint)
+        params.set('token_type_hint', opts.tokenTypeHint);
+    const authValue = auth.type === 'bearer' ? `Bearer ${auth.value}` : `Basic ${auth.value}`;
+    const res = await doFetch(url, {
+        method: 'POST',
+        headers: {
+            authorization: authValue,
+            'content-type': 'application/x-www-form-urlencoded',
+        },
+        body: params.toString(),
+    });
+    if (!res.ok)
+        return null;
+    const data = await res.json();
+    if (!data?.active)
+        return null;
+    return data;
+}

package/build/src/resolvers/jwt_resolver.d.ts

@@ -0,0 +1,20 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { Identity, SessionResolver } from '@adonis-agora/authkit-core';
+export interface JwtResolverConfig {
+    issuer: string;
+    jwksUri: string;
+    audience: string;
+    globalRolesClaim: string;
+    /** algoritmos de assinatura aceitos (defesa contra alg-confusion). Default: asimétricos. */
+    algorithms?: string[];
+    /** de onde extrair o token cru no request; injetado pelo factory */
+    getToken?: (ctx: HttpContext) => string | null;
+}
+export declare class JwtResolver implements SessionResolver {
+    #private;
+    private config;
+    constructor(config: JwtResolverConfig);
+    /** Valida um JWT cru e monta a Identity (ou null se inválido). */
+    resolveToken(token: string): Promise<Identity | null>;
+    resolve(ctx: HttpContext): Promise<Identity | null>;
+}

package/build/src/resolvers/jwt_resolver.js

@@ -0,0 +1,34 @@
+import { createRemoteJWKSet, jwtVerify } from 'jose';
+import { buildIdentityFromClaims } from './identity.js';
+const DEFAULT_ALGS = ['RS256', 'RS384', 'RS512', 'PS256', 'PS384', 'PS512', 'ES256', 'ES384', 'ES512', 'EdDSA'];
+export class JwtResolver {
+    config;
+    #jwks;
+    constructor(config) {
+        this.config = config;
+        this.#jwks = createRemoteJWKSet(new URL(config.jwksUri));
+    }
+    /** Valida um JWT cru e monta a Identity (ou null se inválido). */
+    async resolveToken(token) {
+        try {
+            const { payload } = await jwtVerify(token, this.#jwks, {
+                issuer: this.config.issuer,
+                audience: this.config.audience,
+                algorithms: this.config.algorithms ?? DEFAULT_ALGS,
+            });
+            // uma identidade válida exige um subject (`sub`)
+            if (!payload.sub)
+                return null;
+            return buildIdentityFromClaims(payload, this.config.globalRolesClaim);
+        }
+        catch {
+            return null;
+        }
+    }
+    async resolve(ctx) {
+        const token = this.config.getToken?.(ctx) ?? null;
+        if (!token)
+            return null;
+        return this.resolveToken(token);
+    }
+}

package/build/src/resolvers/opaque_resolver.d.ts

@@ -0,0 +1,43 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { Identity, SessionResolver } from '@adonis-agora/authkit-core';
+import { type TokenSource } from '../token_source.js';
+type FetchImpl = (url: string, init: any) => Promise<{
+    ok: boolean;
+    json: () => Promise<any>;
+}>;
+export interface OpaqueResolverConfig {
+    /** Endpoint de introspection do IdP (RFC 7662). Ex.: `${issuer}/token/introspection`. */
+    introspectionUrl: string;
+    /** client_id usado para autenticar a introspection (client confidencial). */
+    clientId: string;
+    /** client_secret correspondente (Basic auth). */
+    clientSecret: string;
+    /** De onde tirar o access token: `session` (TokenSet) ou `bearer` (header). */
+    tokenSource: TokenSource;
+    /** Chave da sessão onde o TokenSet está guardado. */
+    sessionKey: string;
+    /** Claim que carrega os papéis globais no payload da introspection. */
+    globalRolesClaim: string;
+    /**
+     * TTL (ms) do cache em memória de respostas `active:true`, para não introspectar
+     * a cada request. Default 0 (sem cache → revogação propaga imediatamente). Suba
+     * para trocar imediatismo por menos round-trips.
+     */
+    cacheTtlMs?: number;
+    fetchImpl?: FetchImpl;
+}
+/**
+ * Resolver de access token OPACO via introspection padrão (RFC 7662) a cada request.
+ *
+ * Diferente do `jwt` (id_token stateless, sem checagem de revogação) e do `pat`
+ * (token `pat_` com segredo compartilhado): aqui o access token opaco emitido pelo
+ * fluxo OIDC é introspectado no IdP a cada request, então uma revogação no IdP
+ * derruba a sessão do app imediatamente (no próximo request, ou após o `cacheTtlMs`).
+ */
+export declare class OpaqueResolver implements SessionResolver {
+    #private;
+    private config;
+    constructor(config: OpaqueResolverConfig);
+    resolve(ctx: HttpContext): Promise<Identity | null>;
+}
+export {};

package/build/src/resolvers/opaque_resolver.js

@@ -0,0 +1,51 @@
+import { getTokenFromSource } from '../token_source.js';
+import { buildIdentityFromClaims, introspectToken } from './identity.js';
+/**
+ * Resolver de access token OPACO via introspection padrão (RFC 7662) a cada request.
+ *
+ * Diferente do `jwt` (id_token stateless, sem checagem de revogação) e do `pat`
+ * (token `pat_` com segredo compartilhado): aqui o access token opaco emitido pelo
+ * fluxo OIDC é introspectado no IdP a cada request, então uma revogação no IdP
+ * derruba a sessão do app imediatamente (no próximo request, ou após o `cacheTtlMs`).
+ */
+export class OpaqueResolver {
+    config;
+    #cache = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    #getToken(ctx) {
+        if (this.config.tokenSource === 'bearer') {
+            return getTokenFromSource(ctx, 'bearer', this.config.sessionKey);
+        }
+        // session: introspectamos o ACCESS token (não o id_token).
+        const tokenSet = ctx.session?.get(this.config.sessionKey);
+        return tokenSet?.accessToken ?? null;
+    }
+    async resolve(ctx) {
+        const token = this.#getToken(ctx);
+        if (!token)
+            return null;
+        const ttl = this.config.cacheTtlMs ?? 0;
+        if (ttl > 0) {
+            const hit = this.#cache.get(token);
+            // `nowMs` vem do ctx (request) para não depender de Date.* — ver #now().
+            if (hit && this.#now() - hit.storedAt < ttl)
+                return hit.identity;
+        }
+        const basic = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString('base64');
+        const data = await introspectToken(this.config.introspectionUrl, token, { type: 'basic', value: basic }, { tokenTypeHint: 'access_token', fetchImpl: this.config.fetchImpl });
+        if (!data) {
+            this.#cache.delete(token);
+            return null;
+        }
+        const identity = buildIdentityFromClaims(data, this.config.globalRolesClaim);
+        if (ttl > 0)
+            this.#cache.set(token, { identity, storedAt: this.#now() });
+        return identity;
+    }
+    /** Relógio monotônico de processo (evita Date.* direto; testável). */
+    #now() {
+        return Math.trunc(performance.now());
+    }
+}

package/build/src/resolvers/pat_resolver.d.ts

@@ -0,0 +1,18 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { Identity, SessionResolver } from '@adonis-agora/authkit-core';
+type FetchImpl = (url: string, init: any) => Promise<{
+    ok: boolean;
+    json: () => Promise<any>;
+}>;
+export interface PatResolverConfig {
+    introspectionUrl: string;
+    introspectionSecret: string;
+    fetchImpl?: FetchImpl;
+}
+export declare class PatResolver implements SessionResolver {
+    #private;
+    private config;
+    constructor(config: PatResolverConfig);
+    resolve(ctx: HttpContext): Promise<Identity | null>;
+}
+export {};

package/build/src/resolvers/pat_resolver.js

@@ -0,0 +1,24 @@
+import { buildIdentityFromClaims, introspectToken } from './identity.js';
+export class PatResolver {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    #getToken(ctx) {
+        const header = ctx.request.header('authorization');
+        if (!header || !header.startsWith('Bearer '))
+            return null;
+        const token = header.slice(7).trim();
+        return token.startsWith('pat_') ? token : null;
+    }
+    async resolve(ctx) {
+        const token = this.#getToken(ctx);
+        if (!token)
+            return null;
+        const data = await introspectToken(this.config.introspectionUrl, token, { type: 'bearer', value: this.config.introspectionSecret }, { fetchImpl: this.config.fetchImpl });
+        if (!data)
+            return null;
+        // PAT carrega os papéis na claim literal `roles`.
+        return buildIdentityFromClaims(data, 'roles');
+    }
+}

package/build/src/revocation/revocation_store.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Store de revogações de sessão para OIDC Back-Channel Logout sobre sessões
+ * COOKIE-BASED (sem store server-side).
+ *
+ * Diferente do {@link SessionIndex} (que mapeia sid/sub -> sessionId local e só
+ * funciona quando há um store de sessão server-side com id estável), este store
+ * implementa o padrão "log de revogação + checagem na request":
+ *
+ *  1. ao receber um logout_token válido, grava-se a revogação (sid e/ou sub);
+ *  2. em toda request, o {@link BackchannelRevocationMiddleware} extrai sid/sub/iat
+ *     do id_token guardado na sessão e pergunta `isRevoked()`;
+ *  3. se revogada, o middleware limpa o token set da sessão local.
+ *
+ * Semântica de revogação:
+ *  - por `sid`  → derruba UMA sessão SSO específica (logout normal no IdP);
+ *  - por `sub`  → derruba TODAS as sessões do usuário criadas ANTES de `revokedAt`
+ *    (revogação em massa). A comparação com o `iat` do id_token garante que logins
+ *    POSTERIORES à revogação continuem válidos.
+ */
+export interface RevocationStore {
+    /** Persiste uma revogação recebida via back-channel logout (ou disparada pelo IdP). */
+    revoke(event: {
+        sid?: string;
+        sub?: string;
+    }): Promise<void>;
+    /**
+     * @param authTime `iat` (epoch seconds) do id_token da sessão local — o momento
+     *   em que ESTA sessão foi estabelecida. Usado para o caso `sub` (massa).
+     */
+    isRevoked(params: {
+        sid?: string;
+        sub?: string;
+        authTime?: number;
+    }): Promise<boolean>;
+    /** Remove revogações mais antigas que `olderThanDays` (default 35). */
+    prune(olderThanDays?: number): Promise<void>;
+}
+export interface LucidRevocationStoreOptions {
+    /**
+     * Conexão Lucid a usar. Default: conexão primária. Aponte para uma conexão cujo
+     * `searchPath` enxergue o schema onde a tabela vive (ex.: `auth`). A tabela é
+     * compartilhável entre apps que apontam para o MESMO banco.
+     */
+    connection?: string;
+    /** Nome da tabela. Default: `auth_session_revocations` (criada pelo schema auto-manage do server). */
+    table?: string;
+    /**
+     * Auto-prune OPORTUNÍSTICO (default LIGADO): ao gravar uma revogação, se já
+     * passou `everyHours` desde o último prune NESTE processo, remove revogações
+     * mais velhas que `olderThanDays`. Dispensa qualquer agendamento no app — a
+     * limpeza vem da lib. `false` desliga. Default `{ everyHours: 24, olderThanDays: 35 }`.
+     */
+    autoPrune?: false | {
+        everyHours?: number;
+        olderThanDays?: number;
+    };
+}
+/** Nome default da tabela — alinhado ao `ensureAuthkitSchema()` do authkit-server. */
+export declare const DEFAULT_REVOCATION_TABLE = "auth_session_revocations";
+/**
+ * Implementação do {@link RevocationStore} sobre `@adonisjs/lucid`. A tabela é
+ * append-only (id auto-increment); a leitura/escrita usa o query builder cru, então
+ * o consumidor NÃO precisa declarar um model.
+ *
+ * Requer `@adonisjs/lucid` instalado (peer dependency). O import é lazy para não
+ * acoplar o pacote a lucid quando este store não é usado.
+ */
+export declare function lucidRevocationStore(options?: LucidRevocationStoreOptions): RevocationStore;

package/build/src/token_source.d.ts

@@ -0,0 +1,3 @@
+import type { HttpContext } from '@adonisjs/core/http';
+export type TokenSource = 'session' | 'bearer';
+export declare function getTokenFromSource(ctx: HttpContext, source: TokenSource, sessionKey: string): string | null;

package/build/src/token_source.js

@@ -0,0 +1,12 @@
+export function getTokenFromSource(ctx, source, sessionKey) {
+    if (source === 'bearer') {
+        const header = ctx.request.header('authorization');
+        if (!header)
+            return null;
+        const [scheme, value] = header.split(' ');
+        return scheme?.toLowerCase() === 'bearer' && value ? value : null;
+    }
+    // session: o ID token (que é JWT) é o token validado por JWKS
+    const tokenSet = ctx.session?.get(sessionKey);
+    return tokenSet?.idToken ?? null;
+}

package/build/src/types.d.ts

@@ -0,0 +1,6 @@
+export interface TokenSet {
+    idToken: string;
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+}

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/build/src/user_resolvers.d.ts

@@ -0,0 +1,41 @@
+import type { Identity } from '@adonis-agora/authkit-core';
+/**
+ * Contexto opcional passado como 2º argumento de `resolveUser`.
+ * Extensão backward-compatible: callbacks `(identity) => ...` ignoram este arg.
+ */
+export interface ResolveUserContext {
+    accessToken?: string;
+}
+/**
+ * Usuário derivado puramente das claims do ID token (caminho claims-only).
+ * Útil em topologia de bancos separados, onde o ID token é "gordo".
+ */
+export interface ClaimsUser {
+    id: string;
+    email: string;
+    name?: string;
+    avatarUrl?: string;
+    globalRoles: string[];
+}
+/**
+ * Converte uma `Identity` (claims OIDC validadas) num objeto de usuário simples.
+ * Pode ser usada diretamente como `resolveUser: identityToUser`.
+ */
+export declare function identityToUser(identity: Identity): ClaimsUser;
+export interface UserinfoResolverOptions {
+    /** endpoint userinfo explícito; tem precedência sobre `issuer` */
+    userinfoEndpoint?: string;
+    /** issuer do IdP; default do endpoint = `${issuer}/me` (oidc-provider) */
+    issuer?: string;
+    /** implementação de fetch (default: global fetch) */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Fábrica de um `resolveUser` que busca o usuário no endpoint userinfo do IdP
+ * usando o access token. Caminho recomendado quando o app precisa de dados
+ * além do que o token carrega (topologia de bancos separados).
+ *
+ * Sem access token (ex.: tokenSource bearer só com ID token), faz fallback
+ * para `identityToUser(identity)`.
+ */
+export declare function createUserinfoResolver(options?: UserinfoResolverOptions): (identity: Identity, context?: ResolveUserContext) => Promise<unknown>;