@adonis-agora/authkit-server 0.58.3 → 0.60.0

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

@@ -72,8 +72,13 @@ export default class AccountOrgsController {
         if (!name || !slug)
             return response.redirect(accountPath('orgs'));
         try {
-            await store.createOrg({ name, slug, ownerAccountId: accountId });
-            await cfg.audit?.record({ type: 'organization.created', accountId, metadata: { slug } });
+            const org = await store.createOrg({ name, slug, ownerAccountId: accountId });
+            await cfg.audit?.record({
+                type: 'organization.created',
+                accountId,
+                orgId: org.id,
+                metadata: { slug },
+            });
         }
         catch {
             // slug duplicado ou outro erro — redireciona sem mensagem de erro específica
@@ -112,6 +117,7 @@ export default class AccountOrgsController {
         await cfg.audit?.record({
             type: 'organization.switched',
             accountId,
+            orgId,
             metadata: { orgId, orgSlug: org.slug },
         });
         return response.redirect(accountPath('orgs'));
@@ -140,6 +146,7 @@ export default class AccountOrgsController {
             await cfg.audit?.record({
                 type: 'organization.member_removed',
                 accountId,
+                orgId: params.id,
                 metadata: { orgId: params.id, self: true },
             });
         }
@@ -217,6 +224,7 @@ export default class AccountOrgsController {
         await cfg.audit?.record({
             type: 'organization.invitation_sent',
             accountId,
+            orgId: params.id,
             metadata: { orgId: params.id, email, role },
         });
         return response.redirect(accountPath('orgs'));
@@ -270,6 +278,7 @@ export default class AccountOrgsController {
             await cfg.audit?.record({
                 type: 'organization.invitation_accepted',
                 accountId,
+                orgId: invitation.organizationId,
                 metadata: { orgId: invitation.organizationId, invitationId: invitation.id },
             });
         }
@@ -294,6 +303,7 @@ export default class AccountOrgsController {
             await cfg.audit?.record({
                 type: 'organization.member_removed',
                 actorId,
+                orgId: params.id,
                 metadata: { orgId: params.id, targetAccountId: params.accountId },
             });
         }
@@ -318,6 +328,7 @@ export default class AccountOrgsController {
         await cfg.audit?.record({
             type: 'organization.invitation_revoked',
             actorId,
+            orgId: params.id,
             metadata: { orgId: params.id, invitationId: params.invId },
         });
         return response.redirect(accountPath('orgs'));

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/register_auth_host.js

@@ -607,6 +607,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.