@adonis-agora/authkit-server 0.82.3 → 0.84.0

package/build/src/host/last_login_method.js

@@ -0,0 +1,119 @@
+/**
+ * "Último método usado" no login (o selo "Last used" do Cloudflare, Vercel, Clerk…).
+ *
+ * O método fica num cookie DESTE DISPOSITIVO, não na conta. É de propósito:
+ *  - o passo 1 (identifier) ainda não sabe quem é o usuário, e é exatamente ali
+ *    que o selo mais ajuda ("da última vez você entrou com Google");
+ *  - guardar por conta e mostrar no passo 2 diria a quem digita um e-mail qualquer
+ *    como aquela conta entra — vazamento de enumeração. O cookie só conta ao
+ *    próprio browser o que ele mesmo fez.
+ *
+ * O cookie não carrega identidade nenhuma (nem e-mail, nem accountId), só o método.
+ * É puramente de SUPERFÍCIE: a tela destaca um botão, mas nada no fluxo muda — os
+ * métodos oferecidos continuam vindo de `authMethods`, e um valor adulterado no
+ * cookie só destaca outro botão (ou nenhum, se não passar na validação).
+ *
+ * Gravado quando o fator PRIMÁRIO é aceito. Numa conta com 2º fator, isso acontece
+ * antes do desafio de MFA: o selo responde "como você se identificou", que é o
+ * botão que a pessoa procura na próxima vez.
+ */
+/** Nome do cookie do último método de login. */
+export const LAST_LOGIN_METHOD_COOKIE = 'authkit_last_login';
+/** Validade do cookie: 1 ano (renovado a cada login). */
+const LAST_LOGIN_METHOD_MAX_AGE = 365 * 24 * 60 * 60;
+const FIXED_METHODS = new Set(['password', 'magic_link', 'otp', 'passkey']);
+/** Ids de provedor/método: mesmo formato curto que vai em rota/config. */
+const QUALIFIED_METHOD = /^(social|custom):[a-z0-9][a-z0-9_-]{0,63}$/i;
+/**
+ * Valida um valor lido do cookie. Só os métodos conhecidos passam; qualquer outra
+ * coisa (ausente, lixo, valor adulterado) vira `undefined` — sem selo.
+ */
+export function normalizeLastLoginMethod(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    if (FIXED_METHODS.has(raw) || QUALIFIED_METHOD.test(raw))
+        return raw;
+    return undefined;
+}
+/** `false` desliga a feature (`login.lastUsedMethod: false`); ausente = ligada. */
+function isEnabled(cfg) {
+    return cfg.login?.lastUsedMethod !== false;
+}
+/**
+ * Lê o último método deste dispositivo para a tela de login. Fail-safe: feature
+ * desligada, ctx sem cookies ou qualquer erro → `undefined` (sem selo).
+ */
+export function readLastLoginMethod(ctx, cfg) {
+    if (!isEnabled(cfg))
+        return undefined;
+    try {
+        return normalizeLastLoginMethod(ctx.request.plainCookie?.(LAST_LOGIN_METHOD_COOKIE));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Registra o método primário que acabou de ser aceito. Grava via resposta do
+ * Adonis; quando o login termina no `interactionFinished` (que encerra a resposta
+ * crua), o `completeLogin` repassa o cookie pendente — ver
+ * {@link relayPendingCookies}. Best-effort: nunca derruba o login.
+ */
+export function rememberLastLoginMethod(ctx, cfg, method) {
+    if (!isEnabled(cfg))
+        return;
+    if (!normalizeLastLoginMethod(method))
+        return;
+    try {
+        ctx.response.plainCookie?.(LAST_LOGIN_METHOD_COOKIE, method, {
+            httpOnly: true,
+            sameSite: 'lax',
+            path: '/',
+            maxAge: LAST_LOGIN_METHOD_MAX_AGE,
+            secure: ctx.request.secure?.() ?? false,
+        });
+    }
+    catch {
+        // Selo é cosmético: falha ao gravar não interfere no login.
+    }
+}
+/**
+ * Repassa os `Set-Cookie` que o handler gravou na resposta do Adonis para a
+ * resposta crua do Node.
+ *
+ * O Adonis só escreve os headers no `finish()`, depois do handler. Mas o
+ * `interactionFinished` do oidc-provider escreve o 303 e dá `res.end()` direto na
+ * resposta crua — quando o Adonis chega no `finish()`, a resposta já saiu e todo
+ * cookie gravado via `ctx.response.cookie()` no mesmo request é descartado em
+ * silêncio. Chamado pelo `completeLogin` logo antes do `interactionFinished`.
+ *
+ * Os cookies saem do Adonis ao serem repassados, então não há como irem em dobro.
+ * O `Set-Cookie` que o próprio oidc-provider grava depois é ACRESCENTADO aos
+ * existentes (a lib `cookies` do Koa preserva o header), então nada se perde.
+ */
+export function relayPendingCookies(ctx) {
+    try {
+        const response = ctx.response;
+        const raw = response?.response;
+        if (!raw || typeof raw.setHeader !== 'function' || raw.headersSent)
+            return;
+        const pending = response.getHeader?.('set-cookie');
+        if (pending === undefined || pending === null)
+            return;
+        const toList = (value) => value === undefined || value === null
+            ? []
+            : Array.isArray(value)
+                ? value.map(String)
+                : [String(value)];
+        // O `getHeader` do Adonis também enxerga o que já está na resposta crua, então
+        // a lista pendente pode repetir o que lá está — dedup preservando a ordem.
+        const cookies = [...new Set([...toList(raw.getHeader?.('set-cookie')), ...toList(pending)])];
+        // O `removeHeader` do Adonis apaga também da resposta crua — por isso vem
+        // ANTES do `setHeader`, que regrava a lista completa.
+        response.removeHeader?.('set-cookie');
+        raw.setHeader('set-cookie', cookies);
+    }
+    catch {
+        // Repasse é best-effort: nunca derruba o login.
+    }
+}

package/build/src/host/register_auth_host.js

@@ -488,6 +488,8 @@ export function registerAuthHost(router, opts = {}) {
     router.get('/auth/otp-unlock/:token', [C.interaction, 'otpUnlock']);
     router.get('/auth/interaction/:uid/signup', [C.registration, 'showSignup']);
     withLogin(router.post('/auth/interaction/:uid/signup', [C.registration, 'signup']));
+    // Confirmação do cadastro passwordless: a conta nasce aqui, não no POST.
+    router.get('/auth/interaction/:uid/signup/confirm', [C.registration, 'signupConfirm']);
     // Recuperação de senha (standalone).
     router.get('/auth/forgot-password', [C.registration, 'showForgot']);
     withLogin(router.post('/auth/forgot-password', [C.registration, 'forgot']));
@@ -499,6 +501,8 @@ export function registerAuthHost(router, opts = {}) {
     if (social) {
         router.get('/auth/:provider/redirect/:uid', [C.social, 'redirect']);
         router.get('/auth/:provider/callback', [C.social, 'callback']);
+        // 2º fator da conta depois do provider (ver AuthSocialConfig.secondFactor).
+        router.get('/auth/interaction/:uid/social/continue', [C.interaction, 'socialContinue']);
     }
     // PAT introspection (server-to-server).
     withIntrospection(router.post('/authkit/pat/introspect', [C.patIntrospection, 'handle']));

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

@@ -0,0 +1,9 @@
+/** Mesma janela do magic link de login. */
+export declare const SIGNUP_TOKEN_TTL = "15 minutes";
+export interface SignupClaim {
+    email: string;
+    fullName: string | null;
+}
+export declare function issueSignupToken(claim: SignupClaim): Promise<string>;
+/** Claim do token, ou `null` se adulterado, de outro propósito ou vencido. */
+export declare function readSignupToken(token: string): Promise<SignupClaim | null>;

package/build/src/host/signup_token.js

@@ -0,0 +1,31 @@
+import { loadEncryptionService } from '../keys/keystore_crypto.js';
+/**
+ * Token do link de confirmação do cadastro passwordless.
+ *
+ * O cadastro não cria a conta no POST: guarda e-mail + nome num token cifrado
+ * (APP_KEY), com prazo e propósito próprios, e a conta só nasce quando o dono do
+ * e-mail abre o link. Assim um envio que falha, ou um e-mail digitado por quem
+ * não é o dono, não deixa conta para trás nem dispara `account.created`.
+ *
+ * Sem estado no banco: a unicidade vem da própria conta — se ela já existe
+ * quando o link é aberto, o link é recusado.
+ */
+const PURPOSE = 'authkit_passwordless_signup';
+/** Mesma janela do magic link de login. */
+export const SIGNUP_TOKEN_TTL = '15 minutes';
+async function encryption() {
+    return (await loadEncryptionService());
+}
+export async function issueSignupToken(claim) {
+    return (await encryption()).encrypt(claim, SIGNUP_TOKEN_TTL, PURPOSE);
+}
+/** Claim do token, ou `null` se adulterado, de outro propósito ou vencido. */
+export async function readSignupToken(token) {
+    const claim = (await encryption()).decrypt(token, PURPOSE);
+    if (!claim || typeof claim.email !== 'string' || claim.email === '')
+        return null;
+    return {
+        email: claim.email,
+        fullName: typeof claim.fullName === 'string' ? claim.fullName : null,
+    };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Passo pendente entre o callback social e o 2º fator, compartilhado pelo
+ * `AuthSocialController` (grava) e pelo `AuthInteractionController` (consome).
+ */
+/**
+ * Login social que passou pelo provider mas ainda deve o 2º fator da conta.
+ * Lido (uma vez) por `AuthInteractionController#socialContinue`.
+ */
+export declare const SOCIAL_PENDING_KEY = "authkit_social_pending";
+/** Validade do passo pendente: o desafio do 2º fator vem logo em seguida. */
+export declare const SOCIAL_PENDING_TTL_MS: number;
+export interface SocialPendingLogin {
+    accountId: string;
+    uid: string;
+    required: boolean;
+    at: number;
+}

package/build/src/host/social_pending.js

@@ -0,0 +1,11 @@
+/**
+ * Passo pendente entre o callback social e o 2º fator, compartilhado pelo
+ * `AuthSocialController` (grava) e pelo `AuthInteractionController` (consome).
+ */
+/**
+ * Login social que passou pelo provider mas ainda deve o 2º fator da conta.
+ * Lido (uma vez) por `AuthInteractionController#socialContinue`.
+ */
+export const SOCIAL_PENDING_KEY = 'authkit_social_pending';
+/** Validade do passo pendente: o desafio do 2º fator vem logo em seguida. */
+export const SOCIAL_PENDING_TTL_MS = 5 * 60 * 1000;