@adonis-agora/authkit-server 0.59.0 → 0.61.0

package/build/src/host/controllers/interaction_controller.js

@@ -1,5 +1,5 @@
 import '../augmentations.js';
-import { supportsMagicLink, supportsOtpLogin, supportsPasskeys, } from '../../accounts/account_store.js';
+import { supportsLoginMethodsPreference, supportsMagicLink, supportsOtpLogin, supportsPasskeys, } from '../../accounts/account_store.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor, isFirstParty } from '../branding.js';
@@ -14,6 +14,7 @@ import { createOtpLockout, generateOtpUnlockToken, rawToDbOtpUnlockToken, resolv
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods, resolveEffectiveMaintenanceMode, resolveEffectiveRegistration, resolveEffectiveSessionPolicy, } from '../runtime_toggles.js';
 import { TRUSTED_DEVICE_COOKIE, buildTrustedDevicePayload, isTrustedDeviceValid, } from '../trusted_device.js';
+import { normalizeUserLoginMethods, resolveEffectiveUserLoginMethods, } from '../user_login_methods.js';
 /**
  * Chave i18n do erro de status de conta (disabled/expired) compartilhada pelos
  * fluxos passwordless (magic link, OTP, passkey).
@@ -73,6 +74,44 @@ export default class AuthInteractionController {
             otpEnabled,
         };
     }
+    /**
+     * Métodos de login com a preferência POR USUÁRIO aplicada (interseção global ×
+     * `login_methods` da conta). Usado em TODO render/POST que já conhece o email
+     * (passo 2+ do login) — o passo 1 (identifier) não tem usuário, então usa só o
+     * global via {@link #loginMethods}.
+     *
+     * Fail-safe: store sem a capacidade, conta inexistente ou qualquer erro →
+     * métodos globais sem alteração (a preferência nunca derruba o login).
+     */
+    async #userScopedLoginMethods(ctx, cfg, email, runtimeSettings) {
+        const base = await this.#loginMethods(ctx, cfg, runtimeSettings);
+        if (!email)
+            return base;
+        try {
+            if (!supportsLoginMethodsPreference(cfg.accountStore))
+                return base;
+            const acc = await cfg.accountStore.findByEmail(email);
+            if (!acc)
+                return base;
+            const pref = await cfg.accountStore.getLoginMethods(acc.id);
+            const normalized = normalizeUserLoginMethods(pref);
+            if (!normalized)
+                return base;
+            const scoped = resolveEffectiveUserLoginMethods(base.authMethods, normalized);
+            const magicLinkCapableConfig = cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore);
+            return {
+                ...base,
+                authMethods: scoped,
+                magicLinkAvailable: scoped.magicLink && magicLinkCapableConfig,
+                // OTP é extensão do magic link — desligar magic link desliga o código.
+                otpEnabled: base.otpEnabled && scoped.magicLink,
+            };
+        }
+        catch {
+            // Preferência nunca derruba o login.
+            return base;
+        }
+    }
     async show(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
@@ -129,7 +168,11 @@ export default class AuthInteractionController {
         // `authMethods`, `magicLinkAvailable` e `otpEnabled` saiam POR CONSTRUÇÃO
         // (o seletor choose-first precisa de `otpEnabled` para oferecer "código").
         // Passa o runtimeSettings já resolvido para maintenance (sem 2ª resolução).
-        const loginMethods = await this.#loginMethods(ctx, cfg, runtimeSettingsForMaintenance);
+        // Com email na sessão (passo 2+), aplica a preferência POR USUÁRIO — os
+        // métodos que o dono da conta desligou não aparecem nem aqui nem nos POSTs.
+        const loginMethods = email
+            ? await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettingsForMaintenance)
+            : await this.#loginMethods(ctx, cfg, runtimeSettingsForMaintenance);
         const authMethods = loginMethods.authMethods;
         if (!email) {
             // Step 1: identifier (email only).
@@ -215,7 +258,7 @@ export default class AuthInteractionController {
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
             return render(ctx, 'login', {
-                ...(await this.#loginMethods(ctx, cfg)),
+                ...(await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings)),
                 uid: ctx.request.param('uid'),
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -226,6 +269,35 @@ export default class AuthInteractionController {
                 botProtection: effectiveBotLogin?.widget,
             });
         }
+        // Preferência por usuário: senha desligada para ESTA conta → recusa ANTES de
+        // verificar credenciais (mesma tela/erro de credencial inválida — não vaza
+        // se a conta existe nem qual preferência está gravada).
+        const userMethodsForLogin = await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings);
+        if (!userMethodsForLogin.authMethods.password) {
+            const found = await cfg.accountStore.findByEmail(email);
+            const account = found
+                ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
+                : null;
+            await cfg.audit?.record({
+                type: 'login.failure',
+                ip,
+                clientId,
+                metadata: { stage: 'password', reason: 'method_disabled_by_user' },
+            });
+            return render(ctx, 'login', {
+                ...userMethodsForLogin,
+                uid: ctx.request.param('uid'),
+                csrfToken: ctx.request.csrfToken,
+                step: 'password',
+                email,
+                account,
+                error: translate(cfg.messages, 'errors.invalid_credentials'),
+                brand,
+                botProtection: effectiveBotLogin?.on.includes('login')
+                    ? effectiveBotLogin.widget
+                    : undefined,
+            });
+        }
         // Verificamos as credenciais ANTES de finalizar a interaction, porque com MFA
         // ligado precisamos exigir o 2º fator e NÃO podemos chamar interactionFinished
         // ainda. A sequência verificação + lockout + auditoria de falha é centralizada
@@ -260,7 +332,7 @@ export default class AuthInteractionController {
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
             return render(ctx, 'login', {
-                ...(await this.#loginMethods(ctx, cfg)),
+                ...userMethodsForLogin,
                 uid: ctx.request.param('uid'),
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -633,6 +705,24 @@ export default class AuthInteractionController {
         // o e-mail e a tela mostrem SÓ aquele método. Ausente/ inválido = both (histórico).
         // NÃO condiciona a emissão de token — os dois continuam saindo co-locados.
         const channel = normalizeLoginChannel(ctx.request.input('channel'));
+        // Preferência por usuário: magic link desligado para ESTA conta → não emite
+        // token (resposta uniforme "enviado", sem vazar a preferência).
+        const userScopedMethods = email && cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore)
+            ? await this.#userScopedLoginMethods(ctx, cfg, email)
+            : null;
+        if (userScopedMethods && !userScopedMethods.authMethods.magicLink) {
+            return render(ctx, 'login', {
+                ...userScopedMethods,
+                uid,
+                csrfToken: ctx.request.csrfToken,
+                step: 'password',
+                email,
+                account: null,
+                brand,
+                magicLinkSent: true,
+                magicChannel: 'none',
+            });
+        }
         if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && email) {
             const ip = ctx.request.ip?.() ?? null;
             const clientId = details.params.client_id ?? null;
@@ -676,7 +766,9 @@ export default class AuthInteractionController {
         // `otpEnabled` vem do spread de `#loginMethods` (mesmo valor do `otpEnabled`
         // local usado acima para decidir a emissão) — não re-declarado aqui.
         return render(ctx, 'login', {
-            ...(await this.#loginMethods(ctx, cfg)),
+            ...(email
+                ? await this.#userScopedLoginMethods(ctx, cfg, email)
+                : await this.#loginMethods(ctx, cfg)),
             uid,
             csrfToken: ctx.request.csrfToken,
             step: 'password',
@@ -715,6 +807,31 @@ export default class AuthInteractionController {
             });
             return ctx.response.redirect(`/auth/interaction/${uid}`);
         }
+        // Preferência por usuário: magic link desligado para esta conta (p. ex. o
+        // token foi emitido antes de o usuário desligar o método) → não materializa
+        // a sessão; volta ao login com erro genérico (não vaza a preferência).
+        const magicScoped = await this.#userScopedLoginMethods(ctx, cfg, acc.email);
+        if (!magicScoped.authMethods.magicLink) {
+            await cfg.audit?.record({
+                type: 'login.failure',
+                accountId: acc.id,
+                email: acc.email,
+                ip,
+                clientId,
+                metadata: { stage: 'magic_link', reason: 'method_disabled_by_user' },
+            });
+            const render = cfg.render;
+            return render(ctx, 'login', {
+                ...magicScoped,
+                uid,
+                csrfToken: ctx.request.csrfToken,
+                step: 'password',
+                email: acc.email,
+                account: null,
+                brand: brandFor(cfg.branding, clientId ?? undefined, undefined),
+                error: translate(cfg.messages, 'errors.invalid_credentials'),
+            });
+        }
         // E-mail não verificado (LGPD/compliance): mesmo com o link válido, não
         // materializa a sessão se a política exige verificação. Volta ao login com erro.
         const magicLinkRuntimeSettings = await resolveRuntimeSettingsOrNoop(ctx);
@@ -729,7 +846,7 @@ export default class AuthInteractionController {
             });
             const render = cfg.render;
             return render(ctx, 'login', {
-                ...(await this.#loginMethods(ctx, cfg)),
+                ...(await this.#userScopedLoginMethods(ctx, cfg, acc.email)),
                 uid,
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -762,7 +879,7 @@ export default class AuthInteractionController {
         if (!magicLinkStatusGate.allowed) {
             const render = cfg.render;
             return render(ctx, 'login', {
-                ...(await this.#loginMethods(ctx, cfg)),
+                ...(await this.#userScopedLoginMethods(ctx, cfg, acc.email)),
                 uid,
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -814,10 +931,10 @@ export default class AuthInteractionController {
             maxAttempts: cfg.login.otp.maxAttempts,
         });
         // Re-render da tela "link enviado" com o campo de código + erro localizado.
-        // `otpEnabled` vem do spread de `#loginMethods` (aqui, após a guarda acima,
-        // vale `true`) — não re-declarado inline.
+        // `otpEnabled` vem do spread (scoped — OTP é extensão do magic link, e a
+        // preferência do usuário que desligou magic link já foi barrada acima).
         const renderOtpError = async (messageKey) => render(ctx, 'login', {
-            ...(await this.#loginMethods(ctx, cfg)),
+            ...(await this.#userScopedLoginMethods(ctx, cfg, email)),
             uid,
             csrfToken: ctx.request.csrfToken,
             step: 'password',
@@ -842,7 +959,7 @@ export default class AuthInteractionController {
                     metadata: { stage: 'otp', reason: 'unverified' },
                 });
                 return render(ctx, 'login', {
-                    ...(await this.#loginMethods(ctx, cfg)),
+                    ...(await this.#userScopedLoginMethods(ctx, cfg, result.account.email)),
                     uid,
                     csrfToken: ctx.request.csrfToken,
                     step: 'password',
@@ -868,7 +985,7 @@ export default class AuthInteractionController {
             });
             if (!otpStatusGate.allowed) {
                 return render(ctx, 'login', {
-                    ...(await this.#loginMethods(ctx, cfg)),
+                    ...(await this.#userScopedLoginMethods(ctx, cfg, result.account.email)),
                     uid,
                     csrfToken: ctx.request.csrfToken,
                     step: 'password',
@@ -1033,6 +1150,36 @@ export default class AuthInteractionController {
                 false)
             : false;
         ctx.session.forget(PASSKEY_AUTH_CHALLENGE_KEY);
+        // Preferência por usuário: passkey desligada para esta conta → recusa a
+        // assertion. Checamos DEPOIS de `ok` para não revelar a preferência no
+        // timing de uma assertion inválida. Aqui vale SÓ a preferência explícita do
+        // usuário (`pref.passkey === false`): os switches globais de passkey já são
+        // aplicados na RENDERIZAÇÃO do botão/passkey-first (e o desafio MFA usa
+        // passkey como 2º fator independente do passkey-first).
+        if (ok && accountId && supportsLoginMethodsPreference(cfg.accountStore)) {
+            const prefAccount = await cfg.accountStore.findById(accountId);
+            const pref = prefAccount
+                ? normalizeUserLoginMethods(await cfg.accountStore.getLoginMethods(prefAccount.id))
+                : null;
+            if (pref?.passkey === false) {
+                await cfg.audit?.record({
+                    type: 'login.failure',
+                    accountId,
+                    ip,
+                    clientId,
+                    metadata: { stage: 'mfa', method: 'webauthn', reason: 'method_disabled_by_user' },
+                });
+                return render(ctx, 'mfa-challenge', {
+                    uid: ctx.request.param('uid'),
+                    csrfToken: ctx.request.csrfToken,
+                    error: translate(cfg.messages, 'mfa_challenge.passkey_error'),
+                    brand,
+                    passkeyAvailable: false,
+                    trustedDevicesEnabled: cfg.trustedDevices.enabled,
+                    trustedDeviceDays: cfg.trustedDevices.days,
+                });
+            }
+        }
         if (!ok) {
             await cfg.audit?.record({
                 type: 'login.failure',

package/build/src/host/controllers/social_controller.js

@@ -1,8 +1,10 @@
 import '../augmentations.js';
 import { randomUUID } from 'node:crypto';
-import { supportsProviderIdentity } from '../../accounts/account_store.js';
+import { supportsLoginMethodsPreference, supportsMagicLink, supportsPasskeys, supportsProviderIdentity, } from '../../accounts/account_store.js';
 import { assertLoginAllowed } from '../login_attempt.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
+import { resolveEffectiveAuthMethods } from '../runtime_toggles.js';
+import { resolveEffectiveUserLoginMethods, } from '../user_login_methods.js';
 const UID_SESSION_KEY = 'authkit_social_uid';
 /**
  * `AllyService.use()` é tipado contra a interface `SocialProviders`, que só é
@@ -13,6 +15,19 @@ const UID_SESSION_KEY = 'authkit_social_uid';
 function useProvider(ctx, provider) {
     return ctx.ally.use(provider);
 }
+/**
+ * Métodos globais efetivos para o gate por usuário do callback social.
+ * Espelha o `#loginMethods` do interaction controller (mesma fonte de
+ * capabilities), sem acoplar os dois controllers.
+ */
+async function resolveGlobalAuthMethodsForUser(cfg, settings) {
+    return await resolveEffectiveAuthMethods(settings, {
+        configuredSocialProviders: cfg.social?.providers ?? [],
+        magicLinkCapable: cfg.passwordless?.magicLink && supportsMagicLink(cfg.accountStore),
+        passkeyCapable: supportsPasskeys(cfg.accountStore),
+        configOverrides: cfg.authMethods,
+    });
+}
 export default class AuthSocialController {
     /** GET /auth/:provider/redirect/:uid — guarda o uid e redireciona para o provider OAuth. */
     async redirect(ctx) {
@@ -118,6 +133,19 @@ export default class AuthSocialController {
             ctx.session.forget(UID_SESSION_KEY);
             return ctx.response.redirect(backToLogin);
         }
+        // Preferência por usuário: método social desligado para esta conta → recusa.
+        // Aplica-se a contas EXISTENTES (identidade ligada ou e-mail conhecido); uma
+        // conta recém-criada pelo callback não tem preferência gravada, então herda
+        // os globais — o gate é no-op para ela por construção.
+        const existingUser = user;
+        if (supportsLoginMethodsPreference(store)) {
+            const pref = await store.getLoginMethods(existingUser.id);
+            const scoped = resolveEffectiveUserLoginMethods(await resolveGlobalAuthMethodsForUser(cfg, settings), pref);
+            if (scoped.social.length === 0) {
+                ctx.session.forget(UID_SESSION_KEY);
+                return ctx.response.redirect(backToLogin);
+            }
+        }
         ctx.session.forget(UID_SESSION_KEY);
         // Conclui a interaction OIDC para este usuário (escreve o 303 de volta ao authorize).
         // O cookie de interaction (path '/') sobrevive ao round-trip do provider OAuth.

package/build/src/host/login_methods_state.d.ts

@@ -0,0 +1,39 @@
+import type { ResolvedServerConfig } from '../define_config.js';
+import type { SettingsCapability } from './runtime_settings.js';
+import { type UserLoginMethods } from './user_login_methods.js';
+/** Resultado compartilhado de "estado de tipos de login" entregue à UI. */
+export interface LoginMethodsState {
+    supported: boolean;
+    /** Preferência crua do usuário; {} = sem preferência (herda globais). */
+    methods: UserLoginMethods | Record<string, never>;
+    /** Estado final por método (global ∩ preferência) — o que a tela de login mostra. */
+    available: {
+        password: boolean;
+        magicLink: boolean;
+        passkey: boolean;
+        social: string[];
+        forgotPassword: boolean;
+    } | null;
+    /** Métodos fora do controle do usuário (globalmente off ou pin de config). */
+    locked: {
+        password: boolean;
+        magicLink: boolean;
+        passkey: boolean;
+        social: boolean;
+    } | null;
+}
+/**
+ * Métodos globais efetivos + pins de config — resolução compartilhada entre o
+ * console (account API) e a API headless. Fail-safe: erro → defaults.
+ */
+export declare function resolveGlobalAuthMethods(settings: SettingsCapability, cfg: ResolvedServerConfig): Promise<{
+    resolved: import("./runtime_toggles.js").ResolvedAuthMethods;
+    locked: (keyof import("./runtime_toggles.js").AuthMethodsConfigOverride)[];
+}>;
+/**
+ * Monta o estado final de tipos de login para uma conta, intersectando a
+ * preferência do usuário com os métodos globais efetivos. Reusado pelo console
+ * de conta (`/account/api/login-methods`) e pela API headless
+ * (`{baseUrl}/login-methods`) — sem duplicar regra.
+ */
+export declare function loginMethodsStateForAccount(accountId: string, store: ResolvedServerConfig['accountStore'], settings: SettingsCapability, cfg: ResolvedServerConfig): Promise<LoginMethodsState>;

package/build/src/host/login_methods_state.js

@@ -0,0 +1,52 @@
+import { supportsMagicLink } from '../accounts/account_store.js';
+import { supportsPasskeys } from '../accounts/account_store.js';
+import { supportsLoginMethodsPreference } from '../accounts/account_store.js';
+import { resolveEffectiveAuthMethods } from './runtime_toggles.js';
+import { configLockedAuthMethods } from './runtime_toggles.js';
+import { normalizeUserLoginMethods, resolveEffectiveUserLoginMethods, } from './user_login_methods.js';
+/**
+ * Métodos globais efetivos + pins de config — resolução compartilhada entre o
+ * console (account API) e a API headless. Fail-safe: erro → defaults.
+ */
+export async function resolveGlobalAuthMethods(settings, cfg) {
+    const resolved = await resolveEffectiveAuthMethods(settings, {
+        configuredSocialProviders: cfg.social?.providers ?? [],
+        magicLinkCapable: cfg.passwordless?.magicLink && supportsMagicLink(cfg.accountStore),
+        passkeyCapable: supportsPasskeys(cfg.accountStore),
+        configOverrides: cfg.authMethods,
+    });
+    return { resolved, locked: configLockedAuthMethods(cfg.authMethods) };
+}
+/**
+ * Monta o estado final de tipos de login para uma conta, intersectando a
+ * preferência do usuário com os métodos globais efetivos. Reusado pelo console
+ * de conta (`/account/api/login-methods`) e pela API headless
+ * (`{baseUrl}/login-methods`) — sem duplicar regra.
+ */
+export async function loginMethodsStateForAccount(accountId, store, settings, cfg) {
+    if (!supportsLoginMethodsPreference(store)) {
+        return { supported: false, methods: {}, available: null, locked: null };
+    }
+    const pref = normalizeUserLoginMethods(await store.getLoginMethods(accountId));
+    const { resolved: global, locked: cfgLocked } = await resolveGlobalAuthMethods(settings, cfg);
+    const effective = resolveEffectiveUserLoginMethods(global, pref);
+    return {
+        supported: true,
+        // Preferência crua do usuário; {} = sem preferência (herda globais).
+        methods: pref ?? {},
+        available: {
+            password: effective.password,
+            magicLink: effective.magicLink,
+            passkey: effective.passkey,
+            social: effective.social,
+            forgotPassword: effective.forgotPassword,
+        },
+        // Métodos que o usuário NÃO pode controlar (globalmente off ou pin de config).
+        locked: {
+            password: !global.password || cfgLocked.includes('password'),
+            magicLink: !global.magicLink || cfgLocked.includes('magicLink'),
+            passkey: !global.passkey || cfgLocked.includes('passkey'),
+            social: global.social.length === 0,
+        },
+    };
+}

package/build/src/host/register_auth_host.js

@@ -201,6 +201,8 @@ const C = {
     apiKeys: () => import('./admin_api/api_keys_controller.js'),
     // Account self-service JSON API (session-authed, under /account/api/*).
     accountApi: () => import('./account_api/account_api_controller.js'),
+    // API headless (Clerk-style) — host-session-authed via `headless.resolveAccountId`.
+    headlessLoginMethods: () => import('./controllers/headless_login_methods_controller.js'),
 };
 /**
  * Monta todas as rotas do host-kit do Authorization Server numa chamada.
@@ -607,6 +609,9 @@ export function registerAuthHost(router, opts = {}) {
         router.delete(`${apiBase}/apps/:clientId`, [C.accountApi, 'revokeApp']);
         // MFA + passkeys.
         router.get(`${apiBase}/mfa`, [C.accountApi, 'mfaStatus']);
+        // Login methods preference (self-service, por usuário).
+        router.get(`${apiBase}/login-methods`, [C.accountApi, 'getLoginMethods']);
+        router.put(`${apiBase}/login-methods`, [C.accountApi, 'updateLoginMethods']);
         router.get(`${apiBase}/passkeys`, [C.accountApi, 'listPasskeys']);
         router.delete(`${apiBase}/passkeys/:id`, [C.accountApi, 'removePasskey']);
         // PATs.
@@ -619,6 +624,19 @@ export function registerAuthHost(router, opts = {}) {
         router.get(`${apiBase}/orgs/:id`, [C.accountApi, 'showOrg']);
     })
         .use([accountGuard]);
+    // API headless (Clerk-style) — montada fora do `accountGuard` (não depende da
+    // sessão de CONTA), autenticada pelo resolver do host (`headless.resolveAccountId`).
+    // `PUT` usa CSRF igual à API do console (middleware de shield do host).
+    const headlessCfg = hostCfg?.headless;
+    if (headlessCfg) {
+        const hb = headlessCfg.baseUrl;
+        router
+            .get(`${hb}/login-methods`, [C.headlessLoginMethods, 'index'])
+            .as('authkit.headless.login_methods.index');
+        router
+            .put(`${hb}/login-methods`, [C.headlessLoginMethods, 'update'])
+            .as('authkit.headless.login_methods.update');
+    }
     // Prefixos resolvidos dos consoles — `null` quando o grupo não foi montado.
     // Compõem o `AuthHostRouteMap` devolvido no fim.
     let resolvedAdminPrefix = null;