@adonis-agora/authkit-server 0.88.1 → 0.90.0

package/build/index.d.ts

@@ -10,6 +10,7 @@ export { appKeyEncrypter, lucidAccountStore } from './src/accounts/lucid_account
 export { AuthOrganization, AuthOrganizationInvitation, AuthOrganizationMember, defaultOrganizationModels, } from './src/accounts/lucid_store/organization_models.js';
 export type { LucidStoresModels, LucidStoresOptions, LucidStoresResult, } from './src/accounts/lucid_stores.js';
 export { lucidStores } from './src/accounts/lucid_stores.js';
+export { type LinkProviderIdentityResult, ProviderIdentities, ProviderIdentitiesUnsupportedError, } from './src/accounts/provider_identities.js';
 export type { PersonalAgentIdentity } from './src/agents/agent_identity.js';
 export { PersonalAgentVerifier } from './src/agents/agent_identity.js';
 export type { PersonalAgentDelegationConfigInput, PersonalAgentRegistration, PersonalAgentResolver, PersonalAgentsConfigInput, ResolvedPersonalAgentsConfig, } from './src/agents/config.js';

package/build/index.js

@@ -7,6 +7,7 @@ export { supportsAccountDeletion, supportsAccountEmailRewrite, supportsAccountIm
 export { appKeyEncrypter, lucidAccountStore } from './src/accounts/lucid_account_store.js';
 export { AuthOrganization, AuthOrganizationInvitation, AuthOrganizationMember, defaultOrganizationModels, } from './src/accounts/lucid_store/organization_models.js';
 export { lucidStores } from './src/accounts/lucid_stores.js';
+export { ProviderIdentities, ProviderIdentitiesUnsupportedError, } from './src/accounts/provider_identities.js';
 export { PersonalAgentVerifier } from './src/agents/agent_identity.js';
 export { personalAgentAuth, personalAgentOf, personalAgentReceipt, personalAgentSecurity, personalAgentStepUp, } from './src/agents/middleware.js';
 export { accessTokenHash, hmacNonceSource, verifyDpopProof, } from './src/agents/poppy/dpop.js';

package/build/src/accounts/provider_identities.d.ts

@@ -0,0 +1,43 @@
+import { type AccountStore, type AuthAccount, type LinkProviderIdentityInput, type ProviderIdentitySummary } from './account_store.js';
+/** O account store não tem account linking (o host não passou `providerIdentityModel`). */
+export declare class ProviderIdentitiesUnsupportedError extends Error {
+    constructor();
+}
+/** Resultado de {@link ProviderIdentities.link}. */
+export interface LinkProviderIdentityResult {
+    /**
+     * Conta a que a identidade estava ligada antes; `null` se era nova. Diferente do
+     * `accountId` pedido = a identidade MUDOU de conta (o "Entrar com <provider>" passa
+     * a abrir a conta nova).
+     */
+    previousAccountId: string | null;
+}
+/**
+ * Identidades de provider (Google, GitHub, …) das contas: a MESMA ligação que o
+ * "Entrar com <provider>" consulta antes de cair no e-mail. Exposto como
+ * `authkit.identities` (`@adonis-agora/authkit-server/services/main`) para o host
+ * ligar uma conta a um provider fora do login social — ex.: quando a pessoa conecta
+ * o Google numa tela de integrações — sem tocar na tabela nem no account store cru.
+ *
+ * Store sem a capacidade: `supported` é `false` e os demais métodos lançam
+ * {@link ProviderIdentitiesUnsupportedError}. Nada falha em silêncio.
+ */
+export declare class ProviderIdentities {
+    #private;
+    constructor(getStore: () => AccountStore);
+    /** O account store tem account linking por provider. */
+    get supported(): boolean;
+    /** A conta ligada a `(provider, providerUserId)`; `null` se ninguém. */
+    find(provider: string, providerUserId: string): Promise<AuthAccount | null>;
+    /**
+     * Liga a identidade à conta. Idempotente na chave `(provider, providerUserId)`: se
+     * ela já estava em OUTRA conta, MUDA para esta (e `previousAccountId` diz de onde).
+     * Só chame depois de provar que a pessoa é dona da identidade (OAuth concluído)
+     * E da conta (sessão nela).
+     */
+    link(input: LinkProviderIdentityInput): Promise<LinkProviderIdentityResult>;
+    /** As identidades da conta, sem tokens. */
+    list(accountId: string): Promise<ProviderIdentitySummary[]>;
+    /** Remove todas as identidades da conta; devolve quantas. */
+    unlinkAll(accountId: string): Promise<number>;
+}

package/build/src/accounts/provider_identities.js

@@ -0,0 +1,58 @@
+import { supportsProviderIdentity, } from './account_store.js';
+/** O account store não tem account linking (o host não passou `providerIdentityModel`). */
+export class ProviderIdentitiesUnsupportedError extends Error {
+    constructor() {
+        super('[authkit] o accountStore não suporta identidades de provider — passe `providerIdentityModel` ao lucidAccountStore');
+        this.name = 'ProviderIdentitiesUnsupportedError';
+    }
+}
+/**
+ * Identidades de provider (Google, GitHub, …) das contas: a MESMA ligação que o
+ * "Entrar com <provider>" consulta antes de cair no e-mail. Exposto como
+ * `authkit.identities` (`@adonis-agora/authkit-server/services/main`) para o host
+ * ligar uma conta a um provider fora do login social — ex.: quando a pessoa conecta
+ * o Google numa tela de integrações — sem tocar na tabela nem no account store cru.
+ *
+ * Store sem a capacidade: `supported` é `false` e os demais métodos lançam
+ * {@link ProviderIdentitiesUnsupportedError}. Nada falha em silêncio.
+ */
+export class ProviderIdentities {
+    #getStore;
+    constructor(getStore) {
+        this.#getStore = getStore;
+    }
+    /** O account store tem account linking por provider. */
+    get supported() {
+        return supportsProviderIdentity(this.#getStore());
+    }
+    #store() {
+        const store = this.#getStore();
+        if (!supportsProviderIdentity(store))
+            throw new ProviderIdentitiesUnsupportedError();
+        return store;
+    }
+    /** A conta ligada a `(provider, providerUserId)`; `null` se ninguém. */
+    find(provider, providerUserId) {
+        return this.#store().findByProviderIdentity(provider, providerUserId);
+    }
+    /**
+     * Liga a identidade à conta. Idempotente na chave `(provider, providerUserId)`: se
+     * ela já estava em OUTRA conta, MUDA para esta (e `previousAccountId` diz de onde).
+     * Só chame depois de provar que a pessoa é dona da identidade (OAuth concluído)
+     * E da conta (sessão nela).
+     */
+    async link(input) {
+        const store = this.#store();
+        const previous = await store.findByProviderIdentity(input.provider, input.providerUserId);
+        await store.linkProviderIdentity(input);
+        return { previousAccountId: previous?.id ?? null };
+    }
+    /** As identidades da conta, sem tokens. */
+    list(accountId) {
+        return this.#store().listProviderIdentities(accountId);
+    }
+    /** Remove todas as identidades da conta; devolve quantas. */
+    unlinkAll(accountId) {
+        return this.#store().unlinkAllProviderIdentities(accountId);
+    }
+}

package/build/src/define_config.d.ts

@@ -122,6 +122,22 @@ export interface MailHooks {
         agentName: string;
         expiresInMinutes: number;
     }) => Promise<void>;
+    /**
+     * Disparado num login bem-sucedido a partir de um IP NOVO para a conta (nenhum
+     * `login.success` anterior desse IP no audit sink), quando `notifications.newLoginEmail`
+     * está ligado. Best-effort, fire-and-forget: uma falha aqui NUNCA quebra o login.
+     * Quando ausente mas o mail estiver configurado, o host-kit envia o e-mail default de
+     * "novo login". O `login.new_ip_notified` é auditado nos dois casos.
+     */
+    onNewLogin?: (data: {
+        account: {
+            id: string;
+            email: string;
+        };
+        ip: string;
+        userAgent?: string | null;
+        timestamp: string;
+    }) => Promise<void>;
     /**
      * Disparado num login bem-sucedido a partir de um dispositivo NOVO (sem cookie
      * de dispositivo confiável válido para a conta). Best-effort, fire-and-forget:

package/build/src/host/login_notify.js

@@ -51,7 +51,12 @@ export async function notifyLoginSuccess(ctx, cfg, input) {
             resolvedEmail = (await cfg.accountStore.findById(accountId))?.email ?? null;
         }
         if (cfg.notifications.newLoginEmail) {
-            await maybeNotifyNewLogin(ctx, cfg, { accountId, email: resolvedEmail, ip: ip ?? null });
+            await maybeNotifyNewLogin(ctx, cfg, {
+                accountId,
+                email: resolvedEmail,
+                ip: ip ?? null,
+                userAgent,
+            });
         }
         if (onNewDevice && cfg.notifications.newDeviceEmail && resolvedEmail) {
             await notifyNewDevice(ctx, cfg, {
@@ -108,12 +113,12 @@ async function notifyNewDevice(ctx, cfg, data) {
 }
 /**
  * Verifica se o IP é novo para a conta (consultando o audit sink por
- * `login.success` do subject) e, se for, envia o e-mail de alerta + audita
- * `login.new_ip_notified`. Degrada para no-op quando: sem IP, sem e-mail, sem
+ * `login.success` do subject) e, se for, envia o alerta (hook `mail.onNewLogin`,
+ * override do host, ou o mailer default) + audita `login.new_ip_notified`. Degrada para no-op quando: sem IP, sem e-mail, sem
  * sink consultável (`list`), ou já houve um login.success deste IP antes.
  */
 async function maybeNotifyNewLogin(ctx, cfg, data) {
-    const { accountId, email, ip } = data;
+    const { accountId, email, ip, userAgent } = data;
     if (!ip || !email)
         return;
     // Sem consulta do histórico não dá pra decidir se o IP é novo → no-op.
@@ -133,7 +138,25 @@ async function maybeNotifyNewLogin(ctx, cfg, data) {
     if (sameIpCount > 1)
         return;
     const when = new Date().toISOString();
-    await sendNewLoginEmail(ctx, cfg, { email, ip, when });
+    if (cfg.mail?.onNewLogin) {
+        // Isolado: o mailer default engole os próprios erros, o hook do host não. Sem
+        // este try, um hook que lança cortaria o audit abaixo e o alerta de novo
+        // dispositivo, que roda depois deste na mesma tarefa.
+        try {
+            await cfg.mail.onNewLogin({
+                account: { id: accountId, email },
+                ip,
+                userAgent,
+                timestamp: when,
+            });
+        }
+        catch (error) {
+            ctx.logger?.error?.({ err: error, accountId }, 'authkit: falha no hook mail.onNewLogin');
+        }
+    }
+    else {
+        await sendNewLoginEmail(ctx, cfg, { email, ip, when });
+    }
     await cfg.audit?.record({
         type: 'login.new_ip_notified',
         accountId,

package/build/src/provider/oidc_service.d.ts

@@ -1,4 +1,5 @@
 import { type MetricsRecorder } from '@adonis-agora/authkit-core';
+import { ProviderIdentities } from '../accounts/provider_identities.js';
 import type { ResolvedServerConfig } from '../define_config.js';
 import { type ManagedKeyInfo } from '../keys/keystore.js';
 import type { KeystoreManager } from '../keys/keystore_manager.js';
@@ -38,6 +39,12 @@ export declare class OidcService {
     /** Holder mutável dos TTLs de access/id/refresh tokens (lido sincronamente pelo oidc-provider). */
     readonly tokenTtlHolder: TokenTtlHolder;
     get config(): ResolvedServerConfig;
+    /**
+     * Identidades de provider das contas — a ligação que o "Entrar com <provider>" usa.
+     * Para o host ligar uma conta a um provider fora do login social sem tocar no
+     * account store cru. Ver {@link ProviderIdentities}.
+     */
+    get identities(): ProviderIdentities;
     /** @internal Loader de JWKS do cofre (usado por reloadKeys). */
     get jwksLoader(): (() => Promise<{
         keys: Record<string, any>[];

package/build/src/provider/oidc_service.js

@@ -2,6 +2,7 @@ import { createHmac, timingSafeEqual } from 'node:crypto';
 import { NoopRecorder } from '@adonis-agora/authkit-core';
 import Koa from 'koa';
 import mount from 'koa-mount';
+import { ProviderIdentities } from '../accounts/provider_identities.js';
 import { normalizeActiveOrg, readActiveOrgFromKoaCtx, verifyActiveOrgMembership, } from '../host/active_org_cookie.js';
 import { isFirstPartyClient } from '../host/branding.js';
 import { listKeyInfos, signingKeyAgeDays, toPublicJwks, } from '../keys/keystore.js';
@@ -66,6 +67,16 @@ export class OidcService {
     get config() {
         return this.#config;
     }
+    #identities;
+    /**
+     * Identidades de provider das contas — a ligação que o "Entrar com <provider>" usa.
+     * Para o host ligar uma conta a um provider fora do login social sem tocar no
+     * account store cru. Ver {@link ProviderIdentities}.
+     */
+    get identities() {
+        this.#identities ??= new ProviderIdentities(() => this.#config.accountStore);
+        return this.#identities;
+    }
     /** @internal Loader de JWKS do cofre (usado por reloadKeys). */
     get jwksLoader() {
         return this.#deps.jwksLoader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.88.1",
+  "version": "0.90.0",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",
@@ -117,8 +117,8 @@
   },
   "devDependencies": {
     "@adonis-agora/authkit-react": "0.26.0",
-    "@adonis-agora/durable": "0.56.7",
-    "@adonis-agora/telescope": "0.23.0",
+    "@adonis-agora/durable": "0.58.2",
+    "@adonis-agora/telescope": "0.27.0",
     "@adonisjs/ally": "6.3.2",
     "@adonisjs/auth": "10.1.0",
     "@adonisjs/core": "7.6.0",