@adonis-agora/authkit-client 0.10.1 → 0.12.0

package/README.md

@@ -26,10 +26,14 @@ router.post('/auth/logout', [OidcSessionController, 'logout'])
 ```ts
 const identity = await ctx.auth.getIdentity()   // claims OIDC validadas (ou null)
 const user = await ctx.auth.getUser()            // model do app (via resolveUser)
-ctx.auth.hasGlobalRole('ADMIN')                  // síncrono, das claims
-await ctx.auth.hasAppRole('COORDINATOR')         // via resolveAppRoles
+ctx.auth.hasGlobalRole('ADMIN')                  // síncrono, das claims (roles do token)
 ```
 
+> **Autorização por app-role saiu do AuthKit.** O AuthKit só autentica e conhece as `globalRoles` do
+> token. Roles do app (numa tabela do domínio) e permissões são do `@adonis-agora/authz` — configure
+> o seam `resolveRoles` lá. Guard de rota por role vai pra authz/Bouncer, não para o `authkit_middleware`
+> (que só exige login).
+
 ## Resolução de sessão
 `resolvers.jwt({ tokenSource })` valida o **ID token** (JWT) por JWKS:
 - `tokenSource: 'session'` (default) — lê o token set do `@adonisjs/session`.
@@ -47,10 +51,6 @@ resolveUser: async (identity) => {
   // FK cross-schema: app.users.auth_user_id -> auth.users.id
   return AppUser.query().where('authUserId', identity.userId).firstOrFail()
 },
-resolveAppRoles: async (identity) => {
-  const u = await AppUser.findByOrFail('authUserId', identity.userId)
-  return u.related('roles').query().then((rs) => rs.map((r) => r.name))
-},
 ```
 
 ### Bancos separados
@@ -69,13 +69,8 @@ import { createUserinfoResolver } from '@adonis-agora/authkit-client'
 resolveUser: createUserinfoResolver({ issuer: env.get('AUTHKIT_ISSUER') }),
 // ou: createUserinfoResolver({ userinfoEndpoint: 'https://idp/me' })
 ```
-Em ambos os casos, `resolveAppRoles` **sempre consulta o banco do próprio app**:
-```ts
-resolveAppRoles: async (identity) => {
-  const roles = await AppRole.query().where('authUserId', identity.userId)
-  return roles.map((r) => r.name)
-},
-```
+Roles do app (a tabela de roles do próprio domínio) não passam mais pelo AuthKit — configure o seam
+`resolveRoles` do `@adonis-agora/authz`, que as une às `globalRoles` do token para decidir permissão.
 
 ## Ordem de middleware (importante)
 O middleware do `@adonisjs/session` DEVE rodar ANTES do `authkit_middleware` no stack `router`

package/build/providers/authkit_client_provider.d.ts

@@ -1,5 +1,5 @@
-import type { ApplicationService } from "@adonisjs/core/types";
 import type { HttpContext } from "@adonisjs/core/http";
+import type { ApplicationService } from "@adonisjs/core/types";
 import { Authenticator } from "../src/authenticator.js";
 import type { ResolvedClientConfig } from "../src/define_config.js";
 /** Deps injetáveis (relógio/fetch) para testar `maybeRefresh` sem rede/tempo real. */

package/build/providers/authkit_client_provider.js

@@ -1,8 +1,8 @@
 import { configProvider } from "@adonisjs/core";
 import { RuntimeException } from "@adonisjs/core/exceptions";
 import { Authenticator } from "../src/authenticator.js";
-import { refreshTokens, exchangeToken } from "../src/oidc_login.js";
 import { validateLogoutToken } from "../src/backchannel_logout.js";
+import { exchangeToken, refreshTokens } from "../src/oidc_login.js";
 /** Margem (ms) antes do `expiresAt` em que o access token é renovado proativamente. */
 const REFRESH_SKEW_MS = 60_000;
 export class AuthkitClientManager {
@@ -161,7 +161,6 @@ export class AuthkitClientManager {
         return new Authenticator(ctx, {
             resolver,
             resolveUser: this.config.resolveUser,
-            resolveAppRoles: this.config.resolveAppRoles,
             getAccessToken: () => {
                 const tokenSet = ctx.session?.get(sessionKey);
                 return tokenSet?.accessToken;

package/build/src/authenticator.d.ts

@@ -1,6 +1,6 @@
-import type { HttpContext } from "@adonisjs/core/http";
 import type { Identity, SessionResolver } from "@adonis-agora/authkit-core";
 import { type MetricsRecorder } from "@adonis-agora/authkit-core";
+import type { HttpContext } from "@adonisjs/core/http";
 /** Contexto opcional repassado a `resolveUser` (extensão backward-compatible). */
 export interface ResolveUserContext {
     accessToken?: string;
@@ -8,11 +8,16 @@ export interface ResolveUserContext {
 export interface AuthenticatorDeps {
     resolver: SessionResolver;
     resolveUser?: (identity: Identity, context: ResolveUserContext) => Promise<unknown>;
-    resolveAppRoles?: (identity: Identity) => Promise<string[]>;
     /** lê o access token do token set da sessão (opcional; usado por resolvers userinfo) */
     getAccessToken?: () => string | null | undefined;
 }
-export declare class Authenticator {
+/**
+ * Autenticador do request. O parâmetro `TUser` é o tipo do usuário do app que `resolveUser`
+ * devolve — o app o fixa via augmentation de `HttpContext.auth` (`auth: Authenticator<AppUser>`),
+ * e aí `getUser()` passa a devolver `AppUser | null` em todo call-site, sem cast. Default `unknown`
+ * mantém o comportamento anterior (nada a mudar em quem não augmenta).
+ */
+export declare class Authenticator<TUser = unknown> {
     #private;
     private ctx;
     private deps;
@@ -22,20 +27,15 @@ export declare class Authenticator {
     authenticate(): Promise<Identity>;
     check(): Promise<boolean>;
     hasGlobalRole(role: string): boolean;
-    hasAppRole(role: string): Promise<boolean>;
-    getUser(): Promise<unknown>;
-    /** Resolve (e cacheia) os app roles da identidade corrente. [] sem identidade/resolver. */
-    getAppRoles(): Promise<string[]>;
+    getUser(): Promise<TUser | null>;
     /**
      * Monta o objeto pronto para compartilhar com o frontend (ex.: Inertia share),
      * casando com o `AuthSharedProps` que o `@adonis-agora/authkit-react` consome.
-     * `abilities` é a união de app roles + global roles (conveniente p/ policies/CASL).
-     * Retorna `null` quando não há sessão.
+     * Retorna `null` quando não há sessão. Autorização (roles de app/permissões)
+     * é responsabilidade do `@adonis-agora/authz` — o AuthKit só autentica.
      */
     toSharedProps(): Promise<{
-        user: unknown;
+        user: TUser | null;
         globalRoles: string[];
-        appRoles: string[];
-        abilities: string[];
     } | null>;
 }

package/build/src/authenticator.js

@@ -1,13 +1,18 @@
-import { AUTHKIT_METRICS, NoopRecorder, } from "@adonis-agora/authkit-core";
+import { AUTHKIT_METRICS, NoopRecorder } from "@adonis-agora/authkit-core";
 import { populateContext } from "./observability/context_bridge.js";
+/**
+ * Autenticador do request. O parâmetro `TUser` é o tipo do usuário do app que `resolveUser`
+ * devolve — o app o fixa via augmentation de `HttpContext.auth` (`auth: Authenticator<AppUser>`),
+ * e aí `getUser()` passa a devolver `AppUser | null` em todo call-site, sem cast. Default `unknown`
+ * mantém o comportamento anterior (nada a mudar em quem não augmenta).
+ */
 export class Authenticator {
     ctx;
     deps;
     #identity = null;
     #resolved = false;
-    #user;
+    #user = null;
     #userResolved = false;
-    #appRoles = null;
     #recorder;
     constructor(ctx, deps, recorder = new NoopRecorder()) {
         this.ctx = ctx;
@@ -51,21 +56,15 @@ export class Authenticator {
     hasGlobalRole(role) {
         return this.#identity?.globalRoles.includes(role) ?? false;
     }
-    async hasAppRole(role) {
-        const identity = await this.getIdentity();
-        if (!identity || !this.deps.resolveAppRoles)
-            return false;
-        if (this.#appRoles === null)
-            this.#appRoles = await this.deps.resolveAppRoles(identity);
-        return this.#appRoles.includes(role);
-    }
     async getUser() {
         if (this.#userResolved)
             return this.#user;
         const identity = await this.getIdentity();
         if (identity && this.deps.resolveUser) {
             const accessToken = this.deps.getAccessToken?.() ?? undefined;
-            this.#user = await this.deps.resolveUser(identity, { accessToken });
+            // `resolveUser` é tipado `Promise<unknown>` (a lib não conhece o model do app); o `TUser`
+            // é a asserção do consumidor, feita UMA vez aqui em vez de em cada call-site de `getUser()`.
+            this.#user = (await this.deps.resolveUser(identity, { accessToken }));
         }
         else {
             this.#user = null;
@@ -73,33 +72,17 @@ export class Authenticator {
         this.#userResolved = true;
         return this.#user;
     }
-    /** Resolve (e cacheia) os app roles da identidade corrente. [] sem identidade/resolver. */
-    async getAppRoles() {
-        const identity = await this.getIdentity();
-        if (!identity || !this.deps.resolveAppRoles)
-            return [];
-        if (this.#appRoles === null)
-            this.#appRoles = await this.deps.resolveAppRoles(identity);
-        return this.#appRoles;
-    }
     /**
      * Monta o objeto pronto para compartilhar com o frontend (ex.: Inertia share),
      * casando com o `AuthSharedProps` que o `@adonis-agora/authkit-react` consome.
-     * `abilities` é a união de app roles + global roles (conveniente p/ policies/CASL).
-     * Retorna `null` quando não há sessão.
+     * Retorna `null` quando não há sessão. Autorização (roles de app/permissões)
+     * é responsabilidade do `@adonis-agora/authz` — o AuthKit só autentica.
      */
     async toSharedProps() {
         const identity = await this.getIdentity();
         if (!identity)
             return null;
         const user = await this.getUser();
-        const globalRoles = identity.globalRoles ?? [];
-        const appRoles = await this.getAppRoles();
-        return {
-            user,
-            globalRoles,
-            appRoles,
-            abilities: [...appRoles, ...globalRoles],
-        };
+        return { user, globalRoles: identity.globalRoles ?? [] };
     }
 }

package/build/src/define_config.d.ts

@@ -1,8 +1,8 @@
 import type { Identity } from "@adonis-agora/authkit-core";
-import { resolvers, type ResolverFactory } from "./resolvers/factory.js";
 import type { SessionIndex } from "./backchannel_logout.js";
-import type { RevocationStore } from "./revocation/revocation_store.js";
 import type { ResiliencePolicy } from "./http/resilient_fetch.js";
+import { type ResolverFactory, resolvers } from "./resolvers/factory.js";
+import type { RevocationStore } from "./revocation/revocation_store.js";
 export { resolvers };
 /** Callback invocado quando um logout_token válido chega via Back-Channel Logout. */
 export type BackchannelLogoutCallback = (event: {
@@ -30,7 +30,6 @@ export interface ClientConfigInput {
     resolveUser?: (identity: Identity, context: {
         accessToken?: string;
     }) => Promise<unknown>;
-    resolveAppRoles?: (identity: Identity) => Promise<string[]>;
     sessionKey?: string;
     scopes?: string[];
     globalRolesClaim?: string;
@@ -66,7 +65,6 @@ export interface ResolvedClientConfig {
     resolveUser?: (identity: Identity, context: {
         accessToken?: string;
     }) => Promise<unknown>;
-    resolveAppRoles?: (identity: Identity) => Promise<string[]>;
     sessionKey: string;
     scopes: string[];
     globalRolesClaim: string;

package/build/src/define_config.js

@@ -22,15 +22,8 @@ export function defineConfig(config) {
             redirectUri: config.redirectUri,
             resolverFactory: config.resolver,
             resolveUser: config.resolveUser,
-            resolveAppRoles: config.resolveAppRoles,
             sessionKey: config.sessionKey ?? "authkit",
-            scopes: config.scopes ?? [
-                "openid",
-                "profile",
-                "email",
-                "offline_access",
-                "roles",
-            ],
+            scopes: config.scopes ?? ["openid", "profile", "email", "offline_access", "roles"],
             globalRolesClaim: config.globalRolesClaim ?? "roles",
             onBackchannelLogout,
             sessionIndex: config.sessionIndex,

package/build/src/middleware/auth_middleware.d.ts

@@ -1,28 +1,12 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import type { NextFn } from '@adonisjs/core/types/http';
 export interface AuthMiddlewareOptions {
-    /**
-     * Papéis aceitos. Passa se o usuário tiver QUALQUER um deles como role global
-     * (claim do IdP) OU como app role (`resolveAppRoles`). Vazio/ausente → só exige login.
-     */
-    roles?: string[];
     /** Para onde redirecionar quando não autenticado. Default: `/auth/login`. */
     redirectTo?: string;
-    /** Para onde redirecionar quando autenticado mas sem o papel exigido. Default: `/unauthorized`. */
-    unauthorizedRedirect?: string;
 }
 /**
- * Middleware de autenticação pronto do AuthKit: exige sessão válida (`ctx.auth.check()`)
- * e, opcionalmente, papéis (global OU app). Substitui o middleware de auth que cada
- * consumidor reescrevia à mão.
- *
- * ```ts
- * // start/kernel.ts
- * export const middleware = router.named({
- *   auth: () => import('@adonis-agora/authkit-client/auth_middleware'),
- * })
- * // uso: .use(middleware.auth({ roles: ['ADVISOR'], redirectTo: '/auth/login' }))
- * ```
+ * Middleware de autenticação do AuthKit: exige sessão válida. Autorização por role saiu daqui — use
+ * `@adonis-agora/authz` (ou Bouncer) na rota. AuthKit só autentica.
  */
 export default class AuthkitAuthMiddleware {
     handle(ctx: HttpContext, next: NextFn, options?: AuthMiddlewareOptions): Promise<any>;

package/build/src/middleware/auth_middleware.js

@@ -1,36 +1,12 @@
 /**
- * Middleware de autenticação pronto do AuthKit: exige sessão válida (`ctx.auth.check()`)
- * e, opcionalmente, papéis (global OU app). Substitui o middleware de auth que cada
- * consumidor reescrevia à mão.
- *
- * ```ts
- * // start/kernel.ts
- * export const middleware = router.named({
- *   auth: () => import('@adonis-agora/authkit-client/auth_middleware'),
- * })
- * // uso: .use(middleware.auth({ roles: ['ADVISOR'], redirectTo: '/auth/login' }))
- * ```
+ * Middleware de autenticação do AuthKit: exige sessão válida. Autorização por role saiu daqui — use
+ * `@adonis-agora/authz` (ou Bouncer) na rota. AuthKit só autentica.
  */
 export default class AuthkitAuthMiddleware {
     async handle(ctx, next, options = {}) {
-        const redirectTo = options.redirectTo ?? '/auth/login';
         const ok = await ctx.auth.check();
         if (!ok)
-            return ctx.response.redirect(redirectTo);
-        if (options.roles?.length) {
-            const isGlobal = options.roles.some((r) => ctx.auth.hasGlobalRole(r));
-            let allowed = isGlobal;
-            if (!allowed) {
-                for (const r of options.roles) {
-                    if (await ctx.auth.hasAppRole(r)) {
-                        allowed = true;
-                        break;
-                    }
-                }
-            }
-            if (!allowed)
-                return ctx.response.redirect(options.unauthorizedRedirect ?? '/unauthorized');
-        }
+            return ctx.response.redirect(options.redirectTo ?? '/auth/login');
         return next();
     }
 }

package/build/src/register_oidc_client.d.ts

@@ -1,14 +1,13 @@
-import type { Router } from '@adonisjs/core/http';
-import type { HttpContext } from '@adonisjs/core/http';
 import type { Identity } from '@adonis-agora/authkit-core';
+import type { HttpContext, Router } from '@adonisjs/core/http';
 /**
  * Mapa role → rota de redirect pós-login. `byGlobalRole` checa as roles globais do
- * IdP (claim); `byAppRole` checa `resolveAppRoles`. A primeira correspondência vence
- * (global antes de app); sem match → `default`.
+ * IdP (claim do token) — a primeira correspondência vence; sem match → `default`.
+ * Autorização por app-role/permissão saiu do AuthKit — use `@adonis-agora/authz`
+ * (ex.: no `afterLogin`) se o destino depender disso.
  */
 export interface PostLoginRedirects {
     byGlobalRole?: Record<string, string>;
-    byAppRole?: Record<string, string>;
     default?: string;
 }
 export interface RegisterOidcClientOptions {
@@ -43,7 +42,7 @@ export interface RegisterOidcClientOptions {
  * import { registerOidcClient } from '@adonis-agora/authkit-client'
  * registerOidcClient(router, {
  *   loginMiddleware: middleware.guest(),
- *   redirects: { byGlobalRole: { ADMIN: '/admin' }, byAppRole: { ADVISOR: '/advisor' }, default: '/' },
+ *   redirects: { byGlobalRole: { ADMIN: '/admin' }, default: '/' },
  * })
  * ```
  */

package/build/src/register_oidc_client.js

@@ -10,7 +10,7 @@ import { buildAuthorizeUrl, buildEndSessionUrl, exchangeCode, generatePkce } fro
  * import { registerOidcClient } from '@adonis-agora/authkit-client'
  * registerOidcClient(router, {
  *   loginMiddleware: middleware.guest(),
- *   redirects: { byGlobalRole: { ADMIN: '/admin' }, byAppRole: { ADVISOR: '/advisor' }, default: '/' },
+ *   redirects: { byGlobalRole: { ADMIN: '/admin' }, default: '/' },
  * })
  * ```
  */
@@ -72,8 +72,8 @@ export function registerOidcClient(router, options = {}) {
         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);
+        // 2) Redirect por role global (do token).
+        const dest = resolveDestination(identity, options.redirects);
         return ctx.response.redirect(dest);
     })
         .as('auth.callback');
@@ -104,8 +104,8 @@ export function registerOidcClient(router, options = {}) {
             .as('auth.backchannel_logout');
     }
 }
-/** Resolve o destino pós-login a partir do mapa de redirects por papel. */
-async function resolveDestination(authenticator, identity, redirects) {
+/** Resolve o destino pós-login a partir do mapa de redirects por role global (do token). */
+function resolveDestination(identity, redirects) {
     if (!redirects)
         return '/';
     const globalRoles = identity?.globalRoles ?? [];
@@ -115,11 +115,5 @@ async function resolveDestination(authenticator, identity, redirects) {
                 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/stubs/config/authkit_client.stub

@@ -11,7 +11,7 @@ const authkitClientConfig = defineConfig({
   redirectUri: env.get('AUTHKIT_REDIRECT_URI'),
   resolver: resolvers.jwt({ tokenSource: 'session' }),
   // resolveUser: async (identity) => User.find(identity.userId),
-  // resolveAppRoles: async (identity) => RoleService.appRolesFor(identity.userId),
+  // Roles do app? Configure `resolveRoles` no @adonis-agora/authz (não aqui — o AuthKit só autentica).
 })
 
 export default authkitClientConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-client",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "AdonisJS OIDC/OAuth2 relying-party (client) toolkit: session-based authentication against an OpenID Connect identity provider, with JWT/PAT user resolvers and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",
@@ -82,7 +82,7 @@
     "ioredis-mock": "^8.9.0",
     "@types/node": "25.9.1",
     "typescript": "6.0.3",
-    "@adonis-agora/authkit-server": "0.35.0"
+    "@adonis-agora/authkit-server": "0.36.0"
   },
   "scripts": {
     "build": "tsc && node -e \"require('node:fs').cpSync('stubs','build/stubs',{recursive:true,filter:(s)=>!s.endsWith('.ts')})\"",

package/stubs/config/authkit_client.stub

@@ -11,7 +11,7 @@ const authkitClientConfig = defineConfig({
   redirectUri: env.get('AUTHKIT_REDIRECT_URI'),
   resolver: resolvers.jwt({ tokenSource: 'session' }),
   // resolveUser: async (identity) => User.find(identity.userId),
-  // resolveAppRoles: async (identity) => RoleService.appRolesFor(identity.userId),
+  // Roles do app? Configure `resolveRoles` no @adonis-agora/authz (não aqui — o AuthKit só autentica).
 })
 
 export default authkitClientConfig