@adonis-agora/authkit-server 0.34.0

package/build/src/accounts/lucid_store/shared.js

@@ -0,0 +1,130 @@
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+export const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+/** Recovery code legível: 10 chars hex em duas metades (ex.: a1b2c-3d4e5). */
+export function generateRecoveryCode() {
+    const raw = randomBytes(5).toString('hex');
+    return `${raw.slice(0, 5)}-${raw.slice(5, 10)}`;
+}
+/** Comparação de hashes hex resistente a timing. */
+export function hashesEqual(a, b) {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ba.length !== bb.length)
+        return false;
+    return timingSafeEqual(ba, bb);
+}
+/**
+ * Indica se o model Lucid tem sua tabela registrada no adapter do DB (runtime probe).
+ * Usado para detectar tabelas opcionais como auth_organizations/members/invitations.
+ * Mais robusto do que checar colunas: detecta a presença da tabela inteira.
+ * Em testes, as tabelas existem se foram criadas na migration do teste.
+ */
+export async function hasTable(db, tableName) {
+    try {
+        return await db.connection().schema.hasTable(tableName);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Repositório do estado de MFA na tabela LIB-OWNED `auth_mfa`, keyed por
+ * `account_id`. Acessa o banco pela CONEXÃO do próprio model (`Model.query().client`),
+ * a mesma usada pelo restante do store — sem exigir migration no host.
+ *
+ * O `upsert` é portável (sqlite + pg sem UPSERT nativo): tenta UPDATE pela PK;
+ * se não afetou nenhuma linha, faz INSERT. `recovery_codes` é serializado como
+ * JSON (string) na escrita e desserializado na leitura (aceita tanto string —
+ * sqlite/text — quanto array já parseado — pg jsonb).
+ */
+export function buildMfaStateRepo(Model) {
+    const TABLE = 'auth_mfa';
+    /** QueryClient ligado à conexão do model (equivale ao `db` do password_history). */
+    function client() {
+        return Model.query().client;
+    }
+    /** Normaliza `recovery_codes` vindo do banco (json string OU array já parseado). */
+    function parseRecoveryCodes(raw) {
+        if (raw === null || raw === undefined)
+            return null;
+        if (Array.isArray(raw))
+            return raw;
+        if (typeof raw === 'string') {
+            try {
+                const parsed = JSON.parse(raw);
+                return Array.isArray(parsed) ? parsed : null;
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /** Converte o valor de `mfa_enabled_at` do banco em epoch ms (ou null). */
+    function toEpochMs(raw) {
+        if (raw === null || raw === undefined)
+            return null;
+        if (raw instanceof Date)
+            return raw.getTime();
+        if (typeof raw === 'number')
+            return raw;
+        if (typeof raw === 'string') {
+            const t = new Date(raw).getTime();
+            return Number.isNaN(t) ? null : t;
+        }
+        // Luxon DateTime (defensivo) — alguns clients podem hidratar assim.
+        if (raw && typeof raw.toMillis === 'function')
+            return raw.toMillis();
+        return null;
+    }
+    return {
+        /** Lê o estado de MFA da conta; null se não há linha em `auth_mfa`. */
+        async read(accountId) {
+            const row = await client().from(TABLE).where('account_id', accountId).first();
+            if (!row)
+                return null;
+            return {
+                totpSecret: row.totp_secret ?? null,
+                mfaEnabledAt: toEpochMs(row.mfa_enabled_at),
+                recoveryCodes: parseRecoveryCodes(row.recovery_codes),
+                lastTotpStep: row.last_totp_step === null || row.last_totp_step === undefined
+                    ? null
+                    : Number(row.last_totp_step),
+            };
+        },
+        /**
+         * Upsert parcial: cria a linha se não existir, senão atualiza apenas os campos
+         * presentes no patch (campos ausentes preservados). Portável (sqlite + pg).
+         */
+        async upsert(accountId, patch) {
+            const update = {};
+            if ('totpSecret' in patch)
+                update.totp_secret = patch.totpSecret ?? null;
+            if ('mfaEnabledAt' in patch) {
+                update.mfa_enabled_at =
+                    patch.mfaEnabledAt === null || patch.mfaEnabledAt === undefined
+                        ? null
+                        : new Date(patch.mfaEnabledAt);
+            }
+            if ('recoveryCodes' in patch) {
+                update.recovery_codes =
+                    patch.recoveryCodes === null || patch.recoveryCodes === undefined
+                        ? null
+                        : JSON.stringify(patch.recoveryCodes);
+            }
+            if ('lastTotpStep' in patch)
+                update.last_totp_step = patch.lastTotpStep ?? null;
+            const affected = await client().from(TABLE).where('account_id', accountId).update(update);
+            // knex update retorna o nº de linhas afetadas (0 = linha ainda não existe).
+            if (!affected) {
+                await client()
+                    .table(TABLE)
+                    .insert({ account_id: accountId, ...update });
+            }
+        },
+        /** Remove o estado de MFA da conta (disable / reset total). No-op se ausente. */
+        async clear(accountId) {
+            await client().from(TABLE).where('account_id', accountId).delete();
+        },
+    };
+}

package/build/src/accounts/lucid_store/status_profile.d.ts

@@ -0,0 +1,34 @@
+import type { AccountDeletionCapability, AccountStatusCapability, EmailVerificationStatusCapability, ProfileCapability } from '../account_store.js';
+import type { LucidStoreContext } from './shared.js';
+/**
+ * Indica se o model declara uma coluna (pela propriedade do model, ex.: `disabledAt`).
+ * Lucid expõe as colunas em `$columnsDefinitions` (Map de propertyName → definição).
+ * Usado para montar as capacidades opcionais SÓ quando a coluna existe — assim o
+ * store degrada graciosamente (capacidade ausente) em models que não têm a coluna.
+ */
+export declare function hasColumn(Model: any, property: string): boolean;
+/**
+ * Status da conta (habilitar/desabilitar) sobre a coluna `disabled_at`
+ * (propriedade `disabledAt`) do model. Só deve ser montado quando a coluna existe
+ * ({@link hasColumn}).
+ */
+export declare function buildStatus(ctx: LucidStoreContext): AccountStatusCapability;
+/**
+ * Edição de perfil (nome/avatar) sobre as colunas `full_name`/`avatar_url` do
+ * model. Grava apenas as colunas que existirem. Só deve ser montado quando ao
+ * menos uma das colunas existe.
+ */
+export declare function buildProfile(ctx: LucidStoreContext): ProfileCapability;
+/**
+ * Estado de verificação de e-mail (leitura) sobre a coluna `email_verified_at`
+ * (propriedade `emailVerifiedAt`) do model. Só deve ser montado quando a coluna
+ * existe ({@link hasColumn}) — caso contrário a capacidade fica ausente e features
+ * como `requireVerifiedEmail` degradam (não bloqueiam).
+ */
+export declare function buildEmailVerificationStatus(ctx: LucidStoreContext): EmailVerificationStatusCapability;
+/**
+ * Deleção (hard delete) da linha da conta. Sempre disponível num model Lucid
+ * (qualquer model pode deletar). Apenas remove a própria conta — o cascade dos
+ * demais artefatos é orquestrado pelo `accountDeletionService` no host.
+ */
+export declare function buildDeletion(ctx: LucidStoreContext): AccountDeletionCapability;

package/build/src/accounts/lucid_store/status_profile.js

@@ -0,0 +1,100 @@
+import { DateTime } from 'luxon';
+/**
+ * Indica se o model declara uma coluna (pela propriedade do model, ex.: `disabledAt`).
+ * Lucid expõe as colunas em `$columnsDefinitions` (Map de propertyName → definição).
+ * Usado para montar as capacidades opcionais SÓ quando a coluna existe — assim o
+ * store degrada graciosamente (capacidade ausente) em models que não têm a coluna.
+ */
+export function hasColumn(Model, property) {
+    const defs = Model?.$columnsDefinitions;
+    if (!defs || typeof defs.has !== 'function')
+        return false;
+    return defs.has(property);
+}
+/**
+ * Status da conta (habilitar/desabilitar) sobre a coluna `disabled_at`
+ * (propriedade `disabledAt`) do model. Só deve ser montado quando a coluna existe
+ * ({@link hasColumn}).
+ */
+export function buildStatus(ctx) {
+    const { Model } = ctx;
+    return {
+        async disableAccount(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return;
+            row.disabledAt = DateTime.now();
+            await row.save();
+        },
+        async enableAccount(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return;
+            row.disabledAt = null;
+            await row.save();
+        },
+        async isDisabled(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            return row.disabledAt !== null && row.disabledAt !== undefined;
+        },
+    };
+}
+/**
+ * Edição de perfil (nome/avatar) sobre as colunas `full_name`/`avatar_url` do
+ * model. Grava apenas as colunas que existirem. Só deve ser montado quando ao
+ * menos uma das colunas existe.
+ */
+export function buildProfile(ctx) {
+    const { Model, toAccount } = ctx;
+    const canName = hasColumn(Model, 'fullName');
+    const canAvatar = hasColumn(Model, 'avatarUrl');
+    return {
+        async updateProfile(accountId, patch) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return null;
+            if (canName && patch.name !== undefined)
+                row.fullName = patch.name;
+            if (canAvatar && patch.avatarUrl !== undefined)
+                row.avatarUrl = patch.avatarUrl;
+            await row.save();
+            return toAccount(row);
+        },
+    };
+}
+/**
+ * Estado de verificação de e-mail (leitura) sobre a coluna `email_verified_at`
+ * (propriedade `emailVerifiedAt`) do model. Só deve ser montado quando a coluna
+ * existe ({@link hasColumn}) — caso contrário a capacidade fica ausente e features
+ * como `requireVerifiedEmail` degradam (não bloqueiam).
+ */
+export function buildEmailVerificationStatus(ctx) {
+    const { Model } = ctx;
+    return {
+        async isEmailVerified(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            return row.emailVerifiedAt !== null && row.emailVerifiedAt !== undefined;
+        },
+    };
+}
+/**
+ * Deleção (hard delete) da linha da conta. Sempre disponível num model Lucid
+ * (qualquer model pode deletar). Apenas remove a própria conta — o cascade dos
+ * demais artefatos é orquestrado pelo `accountDeletionService` no host.
+ */
+export function buildDeletion(ctx) {
+    const { Model } = ctx;
+    return {
+        async deleteAccount(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            await row.delete();
+            return true;
+        },
+    };
+}

package/build/src/accounts/lucid_store/webauthn.d.ts

@@ -0,0 +1,8 @@
+import type { WebauthnCapability } from '../account_store.js';
+import { type LucidStoreContext, type ResolvedRp, type WebauthnCeremonies } from './shared.js';
+/**
+ * Capacidade de passkeys / WebAuthn (2º fator alternativo ao TOTP). Só é montada
+ * quando o `webauthnCredentialModel` é fornecido — ausente, a capacidade inteira
+ * fica ABSENTE do store (a UI esconde a seção de passkeys).
+ */
+export declare function buildWebauthn(ctx: LucidStoreContext, Credential: any, webauthn: ResolvedRp, ceremonies: WebauthnCeremonies): WebauthnCapability;

package/build/src/accounts/lucid_store/webauthn.js

@@ -0,0 +1,140 @@
+import { buildMfaStateRepo, } from './shared.js';
+/**
+ * Capacidade de passkeys / WebAuthn (2º fator alternativo ao TOTP). Só é montada
+ * quando o `webauthnCredentialModel` é fornecido — ausente, a capacidade inteira
+ * fica ABSENTE do store (a UI esconde a seção de passkeys).
+ */
+export function buildWebauthn(ctx, Credential, webauthn, ceremonies) {
+    const { Model } = ctx;
+    // Estado de MFA é LIB-OWNED (tabela `auth_mfa`): registrar uma passkey habilita
+    // o MFA gravando `mfa_enabled_at` em `auth_mfa`, não numa coluna do model.
+    const mfaState = buildMfaStateRepo(Model);
+    return {
+        async generatePasskeyRegistrationOptions(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return null;
+            const existing = await Credential.query().where('accountId', accountId);
+            const options = await ceremonies.generateRegistrationOptions({
+                rpName: webauthn.rpName,
+                rpID: webauthn.rpId,
+                userName: row.email,
+                userDisplayName: row.fullName ?? row.email,
+                // Não pede attestation (privacidade); confia na verificação local.
+                attestationType: 'none',
+                // Evita registrar a mesma credencial duas vezes.
+                excludeCredentials: existing.map((c) => ({
+                    id: c.id,
+                    transports: (c.transports ?? undefined),
+                })),
+                authenticatorSelection: { residentKey: 'preferred', userVerification: 'preferred' },
+            });
+            return {
+                options: options,
+                challenge: options.challenge,
+            };
+        },
+        async verifyPasskeyRegistration(accountId, response, expectedChallenge) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            let verification;
+            try {
+                verification = await ceremonies.verifyRegistrationResponse({
+                    response: response,
+                    expectedChallenge,
+                    expectedOrigin: webauthn.origin,
+                    expectedRPID: webauthn.rpId,
+                });
+            }
+            catch {
+                return false;
+            }
+            if (!verification.verified || !verification.registrationInfo)
+                return false;
+            const { credential } = verification.registrationInfo;
+            // publicKey vem como Uint8Array → armazenamos como base64url (texto).
+            const publicKey = Buffer.from(credential.publicKey).toString('base64url');
+            await Credential.create({
+                id: credential.id,
+                accountId,
+                publicKey,
+                counter: credential.counter,
+                transports: credential.transports ?? null,
+                label: null,
+            });
+            // Registrar uma passkey também habilita o MFA (2º fator presente). O estado
+            // vive em `auth_mfa`: só seta `mfa_enabled_at` se ainda não estiver habilitado
+            // (preserva o instante do enrollment original — importante p/ trusted-device).
+            const current = await mfaState.read(accountId);
+            if (!current?.mfaEnabledAt) {
+                await mfaState.upsert(accountId, { mfaEnabledAt: Date.now() });
+            }
+            return true;
+        },
+        async generatePasskeyAuthenticationOptions(accountId) {
+            const creds = await Credential.query().where('accountId', accountId);
+            if (creds.length === 0)
+                return null;
+            const options = await ceremonies.generateAuthenticationOptions({
+                rpID: webauthn.rpId,
+                allowCredentials: creds.map((c) => ({
+                    id: c.id,
+                    transports: (c.transports ?? undefined),
+                })),
+                userVerification: 'preferred',
+            });
+            return {
+                options: options,
+                challenge: options.challenge,
+            };
+        },
+        async verifyPasskeyAuthentication(accountId, response, expectedChallenge) {
+            const resp = response;
+            // O credential id vem na resposta (base64url) → acha a credencial da conta.
+            const cred = await Credential.query()
+                .where('accountId', accountId)
+                .where('id', resp?.id ?? '')
+                .first();
+            if (!cred)
+                return false;
+            let verification;
+            try {
+                verification = await ceremonies.verifyAuthenticationResponse({
+                    response: resp,
+                    expectedChallenge,
+                    expectedOrigin: webauthn.origin,
+                    expectedRPID: webauthn.rpId,
+                    credential: {
+                        id: cred.id,
+                        publicKey: new Uint8Array(Buffer.from(cred.publicKey, 'base64url')),
+                        counter: cred.counter,
+                        transports: (cred.transports ?? undefined),
+                    },
+                });
+            }
+            catch {
+                return false;
+            }
+            if (!verification.verified)
+                return false;
+            // Atualiza o signature counter (anti-replay).
+            cred.counter = verification.authenticationInfo.newCounter;
+            await cred.save();
+            return true;
+        },
+        async listPasskeys(accountId) {
+            const creds = await Credential.query()
+                .where('accountId', accountId)
+                .orderBy('createdAt', 'asc');
+            return creds.map((c) => ({
+                id: c.id,
+                label: c.label ?? undefined,
+                createdAt: c.createdAt?.toISO?.() ?? String(c.createdAt ?? ''),
+            }));
+        },
+        async removePasskey(accountId, credentialId) {
+            await Credential.query().where('accountId', accountId).where('id', credentialId).delete();
+        },
+    };
+}

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

@@ -0,0 +1,45 @@
+import { type LucidAccountStoreOptions } from './lucid_account_store.js';
+import type { AccountStore } from './account_store.js';
+import type { PatStore } from '../pat/pat_store.js';
+import type { AuditSink } from '../audit/audit_sink.js';
+/** Models Lucid (compostos dos mixins do authkit) para montar os stores de uma vez. */
+export interface LucidStoresModels {
+    /** Model de `withAuthUser()` (+withCredentials/+withMfa). Obrigatório. */
+    account: any;
+    /** Model de `withPersonalAccessToken()` — habilita o patStore. */
+    pat?: any;
+    /** Model de `withAuditLog()` — habilita o audit sink. */
+    audit?: any;
+    /** Model de `withProviderIdentity()` — habilita account linking social. */
+    providerIdentity?: any;
+    /** Model de `withWebauthnCredential()` — habilita passkeys. */
+    webauthnCredential?: any;
+    /** Trio de models de organizations — habilita multi-tenancy. */
+    organizations?: {
+        OrgModel: any;
+        MemberModel: any;
+        InvitationModel: any;
+    };
+}
+export interface LucidStoresResult {
+    accountStore: AccountStore;
+    patStore?: PatStore;
+    audit?: AuditSink;
+}
+/** Options compartilhadas — os models vão em {@link LucidStoresModels}, não aqui. */
+export type LucidStoresOptions = Omit<LucidAccountStoreOptions, 'providerIdentityModel' | 'webauthnCredentialModel' | 'organizationModels'>;
+/**
+ * Conveniência que monta `accountStore` (+ `patStore` + `audit`) a partir dos models,
+ * declarando `mfaIssuer`/`webauthn`/`encrypter` UMA vez. Substitui o wiring repetido
+ * de 5–8 models passados um a um no `config/authkit.ts`.
+ *
+ * ```ts
+ * const { accountStore, patStore, audit } = lucidStores(
+ *   { account: AuthUser, pat: PersonalAccessToken, audit: AuditLog,
+ *     providerIdentity: ProviderIdentity, webauthnCredential: WebauthnCredential,
+ *     organizations: { OrgModel: Organization, MemberModel: OrganizationMember, InvitationModel: OrganizationInvitation } },
+ *   { mfaIssuer: 'educ(a)ção', webauthn }
+ * )
+ * ```
+ */
+export declare function lucidStores(models: LucidStoresModels, options?: LucidStoresOptions): LucidStoresResult;

package/build/src/accounts/lucid_stores.js

@@ -0,0 +1,30 @@
+import { lucidAccountStore } from './lucid_account_store.js';
+import { lucidPatStore } from '../pat/lucid_pat_store.js';
+import { lucidAuditSink } from '../audit/lucid_audit_sink.js';
+/**
+ * Conveniência que monta `accountStore` (+ `patStore` + `audit`) a partir dos models,
+ * declarando `mfaIssuer`/`webauthn`/`encrypter` UMA vez. Substitui o wiring repetido
+ * de 5–8 models passados um a um no `config/authkit.ts`.
+ *
+ * ```ts
+ * const { accountStore, patStore, audit } = lucidStores(
+ *   { account: AuthUser, pat: PersonalAccessToken, audit: AuditLog,
+ *     providerIdentity: ProviderIdentity, webauthnCredential: WebauthnCredential,
+ *     organizations: { OrgModel: Organization, MemberModel: OrganizationMember, InvitationModel: OrganizationInvitation } },
+ *   { mfaIssuer: 'educ(a)ção', webauthn }
+ * )
+ * ```
+ */
+export function lucidStores(models, options = {}) {
+    const accountStore = lucidAccountStore(models.account, {
+        ...options,
+        providerIdentityModel: models.providerIdentity,
+        webauthnCredentialModel: models.webauthnCredential,
+        organizationModels: models.organizations,
+    });
+    return {
+        accountStore,
+        ...(models.pat ? { patStore: lucidPatStore(models.pat) } : {}),
+        ...(models.audit ? { audit: lucidAuditSink(models.audit) } : {}),
+    };
+}

package/build/src/adapters/adapter_contract.d.ts

@@ -0,0 +1,37 @@
+/** Forma mínima do payload persistido pelo oidc-provider. */
+export interface OidcPayload {
+    [key: string]: unknown;
+    grantId?: string;
+    userCode?: string;
+    uid?: string;
+    consumed?: unknown;
+}
+/** Um client OIDC enumerado do adapter (id + payload de metadata persistido). */
+export interface EnumeratedClient {
+    clientId: string;
+    payload: Record<string, unknown>;
+}
+/** Um artefato OIDC enumerado de um model qualquer (id + payload persistido). */
+export interface EnumeratedArtifact {
+    id: string;
+    payload: Record<string, unknown>;
+}
+/** Contrato que o oidc-provider espera de um adapter (um por model). */
+export interface OidcAdapter {
+    upsert(id: string, payload: OidcPayload, expiresIn: number): Promise<void>;
+    find(id: string): Promise<OidcPayload | undefined>;
+    findByUserCode(userCode: string): Promise<OidcPayload | undefined>;
+    findByUid(uid: string): Promise<OidcPayload | undefined>;
+    consume(id: string): Promise<void>;
+    destroy(id: string): Promise<void>;
+    revokeByGrantId(grantId: string): Promise<void>;
+    /**
+     * Enumeração GENÉRICA dos artefatos do model deste adapter (id + payload). Usada
+     * pelo console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens
+     * (sessões ativas + revogação). Capacidade OPCIONAL (estilo `AuditSink.list`):
+     * adapters que não conseguem enumerar de forma barata omitem o método e a UI
+     * degrada graciosamente. O adapter já é escopado a UM model na construção
+     * (`new AdapterClass(model)`), então não recebe parâmetro.
+     */
+    list?(): Promise<EnumeratedArtifact[]>;
+}

package/build/src/adapters/adapter_contract.js

@@ -0,0 +1 @@
+export {};

package/build/src/adapters/database_adapter.d.ts

@@ -0,0 +1,21 @@
+import type { Database } from '@adonisjs/lucid/database';
+import type { EnumeratedArtifact, OidcAdapter, OidcPayload } from './adapter_contract.js';
+export declare class DatabaseAdapter implements OidcAdapter {
+    #private;
+    private name;
+    private db;
+    constructor(name: string, db: Database);
+    upsert(id: string, payload: OidcPayload, expiresIn: number): Promise<void>;
+    find(id: string): Promise<OidcPayload | undefined>;
+    findByUid(uid: string): Promise<OidcPayload | undefined>;
+    findByUserCode(userCode: string): Promise<OidcPayload | undefined>;
+    consume(id: string): Promise<void>;
+    destroy(id: string): Promise<void>;
+    revokeByGrantId(grantId: string): Promise<void>;
+    /**
+     * Enumeração genérica dos artefatos do model deste adapter (id + payload).
+     * Filtra por `model_name = this.name` e descarta linhas expiradas. Usada pelo
+     * console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens.
+     */
+    list(): Promise<EnumeratedArtifact[]>;
+}

package/build/src/adapters/database_adapter.js

@@ -0,0 +1,79 @@
+const TABLE = 'authkit_oidc_payloads';
+export class DatabaseAdapter {
+    name;
+    db;
+    constructor(name, db) {
+        this.name = name;
+        this.db = db;
+    }
+    #query() {
+        return this.db.query().from(TABLE).where('model_name', this.name);
+    }
+    async upsert(id, payload, expiresIn) {
+        // Armazenamos como ISO string para que o parse de expiração seja determinístico
+        // independente do backend (SQLite/Postgres) e do formato nativo de timestamp.
+        const expiresAt = expiresIn ? new Date(Date.now() + expiresIn * 1000).toISOString() : null;
+        const row = {
+            id,
+            model_name: this.name,
+            payload: JSON.stringify(payload),
+            grant_id: payload.grantId ?? null,
+            user_code: payload.userCode ?? null,
+            uid: payload.uid ?? null,
+            expires_at: expiresAt,
+        };
+        const existing = await this.#query().where('id', id).first();
+        if (existing) {
+            await this.#query().where('id', id).update(row);
+        }
+        else {
+            await this.db.table(TABLE).insert(row);
+        }
+    }
+    async #parse(record) {
+        if (!record)
+            return undefined;
+        if (record.expires_at && new Date(record.expires_at).getTime() <= Date.now()) {
+            return undefined;
+        }
+        return JSON.parse(record.payload);
+    }
+    async find(id) {
+        return this.#parse(await this.#query().where('id', id).first());
+    }
+    async findByUid(uid) {
+        return this.#parse(await this.#query().where('uid', uid).first());
+    }
+    async findByUserCode(userCode) {
+        return this.#parse(await this.#query().where('user_code', userCode).first());
+    }
+    async consume(id) {
+        const found = await this.find(id);
+        if (!found)
+            return;
+        found.consumed = Math.floor(Date.now() / 1000);
+        await this.#query().where('id', id).update({ payload: JSON.stringify(found) });
+    }
+    async destroy(id) {
+        await this.#query().where('id', id).delete();
+    }
+    async revokeByGrantId(grantId) {
+        await this.db.query().from(TABLE).where('grant_id', grantId).delete();
+    }
+    /**
+     * Enumeração genérica dos artefatos do model deste adapter (id + payload).
+     * Filtra por `model_name = this.name` e descarta linhas expiradas. Usada pelo
+     * console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens.
+     */
+    async list() {
+        const rows = await this.#query().orderBy('id', 'asc');
+        const now = Date.now();
+        const result = [];
+        for (const row of rows) {
+            if (row.expires_at && new Date(row.expires_at).getTime() <= now)
+                continue;
+            result.push({ id: row.id, payload: JSON.parse(row.payload) });
+        }
+        return result;
+    }
+}

package/build/src/adapters/factory.d.ts

@@ -0,0 +1,30 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { OidcAdapter } from './adapter_contract.js';
+export type OidcAdapterClass = new (name: string) => OidcAdapter;
+export interface AdapterFactory {
+    resolver(app: ApplicationService): Promise<OidcAdapterClass>;
+}
+export interface RedisAdapterConfig {
+    /** nome da conexão do @adonisjs/redis */
+    connection: string;
+    prefix?: string;
+}
+export interface DatabaseAdapterConfig {
+    /** nome da conexão Lucid (default: a primária) */
+    connection?: string;
+}
+export declare const adapters: {
+    /**
+     * Factory para o adapter Redis. O consumidor precisa ter o @adonisjs/redis
+     * configurado, pois o resolver resolve o `RedisManager` pelo token `'redis'`
+     * do container e obtém a conexão nomeada via `connection(name)`.
+     */
+    redis(config: RedisAdapterConfig): AdapterFactory;
+    /**
+     * Factory para o adapter de banco (Lucid). Resolve o `Database` manager pelo
+     * token `'lucid.db'`. O `DatabaseAdapter` consome o manager diretamente
+     * (`db.query()`/`db.table()`); quando uma conexão específica é solicitada,
+     * usamos `db.connection(name)` para obter o cliente daquela conexão.
+     */
+    database(config?: DatabaseAdapterConfig): AdapterFactory;
+};