@dudousxd/adonis-authkit-server 0.1.1 → 0.2.0

package/build/index.d.ts

@@ -6,11 +6,12 @@ export { withMfa } from './src/mixins/with_mfa.js';
 export { OidcService } from './src/provider/oidc_service.js';
 export { registerOidcRoutes } from './src/register_routes.js';
 export type { AuthServerConfigInput, ResolvedServerConfig, DynamicRegistrationConfigInput, ResolvedDynamicRegistrationConfig, AdminConfigInput, ResolvedAdminConfig, } from './src/define_config.js';
-export { resolveAdmin, resolveWebauthn } from './src/define_config.js';
+export { resolveAdmin, resolveWebauthn, resolveDynamicRegistration } from './src/define_config.js';
 export type { WebauthnConfigInput, ResolvedWebauthnConfig } from './src/define_config.js';
 export { lucidAccountStore } from './src/accounts/lucid_account_store.js';
 export type { LucidAccountStoreOptions, AccountSecretEncrypter, } from './src/accounts/lucid_account_store.js';
-export type { AccountStore, AuthAccount, CreateAccountInput, LinkProviderIdentityInput, ListAccountsParams, Paginated, PasskeySummary, } from './src/accounts/account_store.js';
+export type { AccountStore, CoreAccountStore, AdminCapability, MfaCapability, WebauthnCapability, ProviderIdentityCapability, AuthAccount, CreateAccountInput, LinkProviderIdentityInput, ListAccountsParams, Paginated, PasskeySummary, } from './src/accounts/account_store.js';
+export { supportsMfa, supportsPasskeys, supportsProviderIdentity, } from './src/accounts/account_store.js';
 export { withProviderIdentity } from './src/mixins/with_provider_identity.js';
 export type { ProviderIdentityRow, ProviderIdentityClass, } from './src/mixins/with_provider_identity.js';
 export { withWebauthnCredential } from './src/mixins/with_webauthn_credential.js';

package/build/index.js

@@ -5,8 +5,9 @@ export { withCredentials } from './src/mixins/with_credentials.js';
 export { withMfa } from './src/mixins/with_mfa.js';
 export { OidcService } from './src/provider/oidc_service.js';
 export { registerOidcRoutes } from './src/register_routes.js';
-export { resolveAdmin, resolveWebauthn } from './src/define_config.js';
+export { resolveAdmin, resolveWebauthn, resolveDynamicRegistration } from './src/define_config.js';
 export { lucidAccountStore } from './src/accounts/lucid_account_store.js';
+export { supportsMfa, supportsPasskeys, supportsProviderIdentity, } from './src/accounts/account_store.js';
 export { withProviderIdentity } from './src/mixins/with_provider_identity.js';
 export { withWebauthnCredential } from './src/mixins/with_webauthn_credential.js';
 export { lucidPatStore } from './src/pat/lucid_pat_store.js';

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

@@ -47,15 +47,20 @@ export interface PasskeySummary {
     /** ISO timestamp de criação. */
     createdAt: string;
 }
-export interface AccountStore {
+/**
+ * Núcleo SEMPRE presente do store de contas: identidade (findById/verifyCredentials),
+ * cadastro, reset de senha, verificação de e-mail e administração (listagem/roles).
+ *
+ * As demais funcionalidades (MFA, passkeys/WebAuthn, account linking por provider)
+ * são CAPACIDADES separadas e opcionais — um store pode implementá-las ou não. Veja
+ * {@link MfaCapability}, {@link WebauthnCapability}, {@link ProviderIdentityCapability}.
+ * O tipo composto usado pela config é {@link AccountStore}.
+ */
+export interface CoreAccountStore extends AdminCapability {
     findById(id: string): Promise<AuthAccount | null>;
     verifyCredentials(email: string, password: string): Promise<AuthAccount | null>;
     findByEmail(email: string): Promise<AuthAccount | null>;
     create(input: CreateAccountInput): Promise<AuthAccount>;
-    /** Acha a conta ligada a uma identidade de provider; null se desconhecida. */
-    findByProviderIdentity(provider: string, providerUserId: string): Promise<AuthAccount | null>;
-    /** Liga (upsert idempotente na chave única) uma identidade de provider a uma conta. */
-    linkProviderIdentity(data: LinkProviderIdentityInput): Promise<void>;
     issuePasswordResetToken(email: string): Promise<{
         token: string;
         account: AuthAccount;
@@ -66,19 +71,45 @@ export interface AccountStore {
         account: AuthAccount;
     } | null>;
     consumeEmailVerificationToken(token: string): Promise<boolean>;
+}
+/**
+ * Administração (console admin opt-in — B6). Hoje faz parte do núcleo (os stores
+ * default sempre a implementam e os controllers admin a chamam direto), mas é
+ * modelada como capacidade própria para clareza e futura granularidade.
+ */
+export interface AdminCapability {
     /** Lista contas paginadas, opcionalmente filtrando por e-mail. */
     listAccounts(params: ListAccountsParams): Promise<Paginated<AuthAccount>>;
     /** Substitui as roles globais de uma conta. */
     setGlobalRoles(accountId: string, roles: string[]): Promise<void>;
+}
+/**
+ * Account linking por identidade de provider (Google, GitHub, …).
+ * `(provider, providerUserId)` é a chave estável vinda do provider OAuth — não
+ * depende do e-mail (que pode mudar / não estar presente). Uma conta pode ter
+ * várias identidades. Stores sem suporte simplesmente NÃO expõem estes métodos
+ * (a capacidade fica ausente) — não há fallback que lança.
+ */
+export interface ProviderIdentityCapability {
+    /** Acha a conta ligada a uma identidade de provider; null se desconhecida. */
+    findByProviderIdentity(provider: string, providerUserId: string): Promise<AuthAccount | null>;
+    /** Liga (upsert idempotente na chave única) uma identidade de provider a uma conta. */
+    linkProviderIdentity(data: LinkProviderIdentityInput): Promise<void>;
+}
+/**
+ * MFA / TOTP. Stores sem suporte a MFA omitem a capacidade inteira; o interaction
+ * flow trata a ausência como "MFA desligado".
+ */
+export interface MfaCapability {
     /** Estado do MFA da conta (se o desafio TOTP deve ser exigido no login). */
-    getMfaState?(accountId: string): Promise<{
+    getMfaState(accountId: string): Promise<{
         enabled: boolean;
     }>;
     /**
      * Inicia o enrollment TOTP: gera um segredo PENDENTE (mfaEnabledAt continua
      * null) e devolve o segredo + otpauth URI (keyuri). Não ativa o MFA ainda.
      */
-    startTotpEnrollment?(accountId: string): Promise<{
+    startTotpEnrollment(accountId: string): Promise<{
         secret: string;
         otpauthUri: string;
     } | null>;
@@ -87,23 +118,33 @@ export interface AccountStore {
      * de sucesso ativa o MFA, gera N recovery codes e devolve os códigos em claro
      * (uma única vez).
      */
-    confirmTotpEnrollment?(accountId: string, code: string): Promise<{
+    confirmTotpEnrollment(accountId: string, code: string): Promise<{
         ok: boolean;
         recoveryCodes?: string[];
     }>;
     /** Verifica um código TOTP contra o segredo ativo. */
-    verifyTotp?(accountId: string, code: string): Promise<boolean>;
+    verifyTotp(accountId: string, code: string): Promise<boolean>;
     /** Consome (single-use) um recovery code; true se casou e foi removido. */
-    consumeRecoveryCode?(accountId: string, code: string): Promise<boolean>;
+    consumeRecoveryCode(accountId: string, code: string): Promise<boolean>;
     /** Desliga o MFA: limpa segredo + mfaEnabledAt + recovery codes. */
-    disableMfa?(accountId: string): Promise<void>;
+    disableMfa(accountId: string): Promise<void>;
+}
+/**
+ * MFA / WebAuthn (passkeys) — 2º fator alternativo ao TOTP. Como o TOTP, é uma
+ * capacidade INTEIRA opcional: stores sem suporte a passkeys não a expõem e a UI
+ * esconde a seção de passkeys. O `expectedChallenge` é gerado no begin
+ * (generate*Options) e DEVE ser guardado pelo controller (na sessão) para ser
+ * passado de volta no finish (verify*) — o store não mantém estado de desafio
+ * entre as chamadas.
+ */
+export interface WebauthnCapability {
     /**
      * Inicia o registro de uma passkey: gera as opções de criação
      * (`generateRegistrationOptions`) escopadas à conta (e excluindo credenciais já
      * registradas). Devolve as opções JSON (o controller serializa pro browser) e o
      * `challenge` (base64url) para guardar na sessão. null = conta inexistente.
      */
-    generatePasskeyRegistrationOptions?(accountId: string): Promise<{
+    generatePasskeyRegistrationOptions(accountId: string): Promise<{
         options: Record<string, unknown>;
         challenge: string;
     } | null>;
@@ -113,13 +154,13 @@ export interface AccountStore {
      * de sucesso persiste a credencial (id, publicKey, counter, transports) e
      * habilita o MFA. Retorna true se registrou.
      */
-    verifyPasskeyRegistration?(accountId: string, response: unknown, expectedChallenge: string): Promise<boolean>;
+    verifyPasskeyRegistration(accountId: string, response: unknown, expectedChallenge: string): Promise<boolean>;
     /**
      * Inicia a autenticação por passkey no login: gera as opções
      * (`generateAuthenticationOptions`) restritas às credenciais da conta. Devolve
      * as opções JSON + o `challenge` para guardar na sessão. null = conta sem passkeys.
      */
-    generatePasskeyAuthenticationOptions?(accountId: string): Promise<{
+    generatePasskeyAuthenticationOptions(accountId: string): Promise<{
         options: Record<string, unknown>;
         challenge: string;
     } | null>;
@@ -128,9 +169,25 @@ export interface AccountStore {
      * (`verifyAuthenticationResponse`) contra o `expectedChallenge` guardado. Em
      * caso de sucesso atualiza o signature counter armazenado. Retorna true se válido.
      */
-    verifyPasskeyAuthentication?(accountId: string, response: unknown, expectedChallenge: string): Promise<boolean>;
+    verifyPasskeyAuthentication(accountId: string, response: unknown, expectedChallenge: string): Promise<boolean>;
     /** Lista as passkeys da conta (sem expor chave pública / counter). */
-    listPasskeys?(accountId: string): Promise<PasskeySummary[]>;
+    listPasskeys(accountId: string): Promise<PasskeySummary[]>;
     /** Remove uma passkey (por credential id) da conta. */
-    removePasskey?(accountId: string, credentialId: string): Promise<void>;
+    removePasskey(accountId: string, credentialId: string): Promise<void>;
 }
+/**
+ * Store de contas usado pela config. É o núcleo SEMPRE presente
+ * ({@link CoreAccountStore}) + as capacidades opcionais (MFA, WebAuthn, account
+ * linking por provider) marcadas como `Partial` — assim configs/hosts existentes
+ * (que referenciam `AccountStore`) compilam sem mudança, e stores que NÃO
+ * implementam uma capacidade simplesmente omitem os métodos (em vez de tê-los
+ * presentes-mas-lançando). Use os type guards {@link supportsMfa},
+ * {@link supportsPasskeys}, {@link supportsProviderIdentity} para estreitar.
+ */
+export type AccountStore = CoreAccountStore & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability>;
+/** Type guard: o store implementa a capacidade de MFA / TOTP. */
+export declare function supportsMfa(store: AccountStore): store is AccountStore & MfaCapability;
+/** Type guard: o store implementa a capacidade de passkeys / WebAuthn. */
+export declare function supportsPasskeys(store: AccountStore): store is AccountStore & WebauthnCapability;
+/** Type guard: o store implementa account linking por identidade de provider. */
+export declare function supportsProviderIdentity(store: AccountStore): store is AccountStore & ProviderIdentityCapability;

package/build/src/accounts/account_store.js

@@ -1 +1,12 @@
-export {};
+/** Type guard: o store implementa a capacidade de MFA / TOTP. */
+export function supportsMfa(store) {
+    return typeof store.getMfaState === 'function';
+}
+/** Type guard: o store implementa a capacidade de passkeys / WebAuthn. */
+export function supportsPasskeys(store) {
+    return typeof store.listPasskeys === 'function';
+}
+/** Type guard: o store implementa account linking por identidade de provider. */
+export function supportsProviderIdentity(store) {
+    return typeof store.findByProviderIdentity === 'function';
+}

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

@@ -1,15 +1,6 @@
-import { generateAuthenticationOptions, generateRegistrationOptions, verifyAuthenticationResponse, verifyRegistrationResponse } from '@simplewebauthn/server';
 import type { AccountStore } from './account_store.js';
-/**
- * Encripta/decripta um valor (ex.: o segredo TOTP) em repouso. Mantém a lib
- * desacoplada do serviço de encryption do app — qualquer implementação que
- * faça round-trip serve (em prod, normalmente o `@adonisjs/core/services/encryption`).
- * `decrypt` retorna `null` se o valor foi adulterado/é inválido.
- */
-export interface AccountSecretEncrypter {
-    encrypt(value: string): string;
-    decrypt(value: string): string | null;
-}
+import { type AccountSecretEncrypter, type WebauthnCeremonies } from './lucid_store/shared.js';
+export type { AccountSecretEncrypter, WebauthnCeremonies };
 /** Opções do {@link lucidAccountStore}. */
 export interface LucidAccountStoreOptions {
     /** Label de issuer mostrado no app autenticador (keyuri). Default: 'AuthKit'. */
@@ -24,15 +15,15 @@ export interface LucidAccountStoreOptions {
     /**
      * Model Lucid das identidades de provider (composto de `withProviderIdentity()`),
      * usado por `findByProviderIdentity`/`linkProviderIdentity` (account linking
-     * social). Ausente → esses dois métodos lançam (hosts email-only continuam
-     * funcionando até optarem por habilitar).
+     * social). Ausente → a capacidade de account linking fica AUSENTE do store (os
+     * métodos não existem; hosts email-only continuam funcionando).
      */
     providerIdentityModel?: any;
     /**
      * Model Lucid das credenciais WebAuthn / passkeys (composto de
-     * `withWebauthnCredential()`), usado pelos métodos `*Passkey*`. Ausente → esses
-     * métodos viram `undefined` na interface (hosts sem passkeys não mudam de
-     * comportamento; a UI esconde a seção de passkeys).
+     * `withWebauthnCredential()`), usado pelos métodos `*Passkey*`. Ausente → a
+     * capacidade de passkeys fica AUSENTE do store (os métodos não existem; a UI
+     * esconde a seção de passkeys).
      */
     webauthnCredentialModel?: any;
     /**
@@ -55,21 +46,15 @@ export interface LucidAccountStoreOptions {
      */
     webauthnCeremonies?: Partial<WebauthnCeremonies>;
 }
-/**
- * Funções das cerimônias WebAuthn. Espelham a assinatura do `@simplewebauthn/server`
- * (subconjunto usado). Injetáveis via {@link LucidAccountStoreOptions.webauthnCeremonies}
- * para testes.
- */
-export interface WebauthnCeremonies {
-    generateRegistrationOptions: typeof generateRegistrationOptions;
-    verifyRegistrationResponse: typeof verifyRegistrationResponse;
-    generateAuthenticationOptions: typeof generateAuthenticationOptions;
-    verifyAuthenticationResponse: typeof verifyAuthenticationResponse;
-}
 /**
  * Implementação default do {@link AccountStore} sobre um model Lucid composto
  * de `withAuthUser()` + `withCredentials()` (+ opcionalmente `withMfa()`). O
  * model carrega `connection`/`table` (app-específico) e, por convenção, uma
  * coluna `fullName` (mapeada de `name`).
+ *
+ * Composição por CAPACIDADE: o núcleo + MFA são sempre montados; passkeys
+ * (WebAuthn) e account linking por provider só são montados quando o model
+ * correspondente é fornecido — caso contrário a capacidade fica ABSENTE (os
+ * métodos não existem no objeto retornado, em vez de presentes-mas-lançando).
  */
 export declare function lucidAccountStore(Model: any, options?: LucidAccountStoreOptions): AccountStore;