@adonis-agora/authkit-server 1.0.0-rc.1 → 1.0.0-rc.11

package/build/src/accounts/lucid_account_store.js

@@ -1,8 +1,9 @@
 import { PasswordManager } from '../password/password_manager.js';
+import { authkitTablesClient, BIND_TABLES_LOCATION, } from '../schema/tables_location.js';
 import { buildCore } from './lucid_store/core.js';
 import { buildLoginMethods, supportsLoginMethodsColumn } from './lucid_store/login_methods.js';
 import { buildMfa } from './lucid_store/mfa.js';
-import { defaultOrganizationModels } from './lucid_store/organization_models.js';
+import { defaultOrganizationModels, organizationModelsOn, } from './lucid_store/organization_models.js';
 import { buildOrganizations } from './lucid_store/organizations.js';
 import { buildPasswordExpiration, buildPasswordHistory } from './lucid_store/password_hygiene.js';
 import { buildProviderIdentity } from './lucid_store/provider_identity.js';
@@ -162,11 +163,23 @@ export function lucidAccountStore(Model, options = {}) {
     // opt-out explícito é `false`. O trio explícito segue como escape hatch.
     const orgModelsOption = options.organizationModels;
     const usesDefaultOrgModels = orgModelsOption === undefined || orgModelsOption === true;
-    const OrgModels = orgModelsOption === false
-        ? undefined
-        : usesDefaultOrgModels
-            ? defaultOrganizationModels
-            : orgModelsOption;
+    const explicitOrgModels = orgModelsOption === false || usesDefaultOrgModels ? undefined : orgModelsOption;
+    /**
+     * Onde vivem as tabelas do AuthKit (`schema.connection`). O `defineConfig` informa
+     * via {@link BIND_TABLES_LOCATION} — o store é construído antes de o config existir.
+     * `null` = ainda não informado (store usado fora do `defineConfig`): as tabelas
+     * lib-owned seguem a conexão do model e os models de org default, a primária.
+     */
+    let tablesLocation = null;
+    const tablesClient = () => {
+        const db = Model.$adapter?.db;
+        if (!tablesLocation || !db)
+            return Model.query().client;
+        return authkitTablesClient(db, tablesLocation);
+    };
+    const orgModels = () => explicitOrgModels ??
+        (tablesLocation ? organizationModelsOn(tablesLocation.connection) : defaultOrganizationModels);
+    const OrgModels = orgModelsOption === false ? undefined : orgModels;
     // RP do WebAuthn: usado nas cerimônias. Default do rpName cai no mfaIssuer.
     const webauthn = options.webauthn ?? {
         rpName: mfaIssuer,
@@ -190,6 +203,7 @@ export function lucidAccountStore(Model, options = {}) {
         audit: options.audit,
         emailVerificationTtlHours: emailTokens.verificationTtlHours,
         emailChangeTtlHours: emailTokens.changeTtlHours,
+        tablesClient,
         // Encripta o segredo antes de persistir (no-op sem encrypter).
         sealSecret: (secret) => (encrypter ? encrypter.encrypt(secret) : secret),
         // Decripta o segredo armazenado; retorna null em falha/adulteração (no-op sem encrypter).
@@ -264,9 +278,15 @@ export function lucidAccountStore(Model, options = {}) {
                 // NÃO faz parte do contrato AccountStore.
                 __organizationModelsSource: usesDefaultOrgModels ? 'default' : 'explicit',
                 ...buildOrganizations({
-                    OrgModel: OrgModels.OrgModel,
-                    MemberModel: OrgModels.MemberModel,
-                    InvitationModel: OrgModels.InvitationModel,
+                    get OrgModel() {
+                        return OrgModels().OrgModel;
+                    },
+                    get MemberModel() {
+                        return OrgModels().MemberModel;
+                    },
+                    get InvitationModel() {
+                        return OrgModels().InvitationModel;
+                    },
                     findAccountEmail: async (accountId) => {
                         const row = await Model.find(accountId);
                         return row?.email ?? null;
@@ -292,11 +312,10 @@ export function lucidAccountStore(Model, options = {}) {
             }
         },
         /**
-         * Nome da conexão Lucid usada por este store (deriva de `Model.connection`).
-         * Exposto para que os call-sites de RuntimeSettings possam passar
-         * `{ connection: store.connectionName }` e usar a conexão correta.
-         * Undefined quando o model usa a conexão default (back-compat total).
-         * NÃO faz parte do contrato AccountStore.
+         * Nome da conexão Lucid do MODEL da conta (deriva de `Model.connection`) — onde
+         * vive a tabela da conta (e a coluna `login_methods`). As tabelas do authkit
+         * NÃO seguem esta conexão: elas usam `schema.connection`.
+         * Undefined quando o model usa a conexão default.
          */
         connectionName: Model.connection ?? undefined,
         /**
@@ -318,10 +337,16 @@ export function lucidAccountStore(Model, options = {}) {
         __model: Model,
     };
     // Histórico de senhas: tabela lib-owned `auth_password_history`, pela conexão
-    // do model (resolvida a cada uso, como no MFA).
+    // das tabelas do authkit (resolvida a cada uso, como no MFA).
     Object.assign(store, buildPasswordHistory(ctx, {
-        query: () => Model.query().client.query(),
-        table: (name) => Model.query().client.table(name),
+        query: () => tablesClient().query(),
+        table: (name) => tablesClient().table(name),
     }));
+    // Não-enumerável: o `defineConfig` informa `schema.connection` por aqui.
+    Object.defineProperty(store, BIND_TABLES_LOCATION, {
+        value: (location) => {
+            tablesLocation = { connection: location.connection };
+        },
+    });
     return store;
 }

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

@@ -8,8 +8,8 @@ import { buildMfaStateRepo, generateRecoveryCode, hashesEqual, sha256, } from '.
  * {@link ensureAuthkitSchema}), keyed por `account_id`. O host NÃO precisa migrar
  * nada e o model não declara colunas de MFA.
  *
- * Acesso ao banco via a CONEXÃO do próprio model (`Model.query().client`), a mesma
- * usada pelo restante do store. O `email` (para o keyuri/QR) continua vindo do
+ * Acesso ao banco pela conexão das tabelas do authkit (`schema.connection`), a
+ * mesma em que o `autoManage` cria `auth_mfa`. O `email` (para o keyuri/QR) continua vindo do
  * model principal — só o ESTADO de MFA migrou para `auth_mfa`.
  */
 /**
@@ -19,7 +19,7 @@ import { buildMfaStateRepo, generateRecoveryCode, hashesEqual, sha256, } from '.
 const TOTP_PERIOD = 30;
 export function buildMfa(ctx) {
     const { Model, mfaIssuer, recoveryCodeCount, sealSecret, openSecret } = ctx;
-    const repo = buildMfaStateRepo(Model);
+    const repo = buildMfaStateRepo(Model, ctx.tablesClient);
     return {
         async getMfaState(accountId) {
             const state = await repo.read(accountId);

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

@@ -10,10 +10,11 @@ import type { DateTime } from 'luxon';
  * pelo `autoManage` sem que o model escrito à mão no host saiba dela, e o
  * sintoma aparece longe da causa.
  *
- * Use com `organizationModels: true` em {@link lucidAccountStore}. O caminho
+ * Use com `organizationModels: true` em {@link lucidAccountStore}. Eles seguem a
+ * conexão das tabelas do authkit (`schema.connection` do `defineConfig`, como
+ * todas as tabelas lib-owned — ver {@link organizationModelsOn}). O caminho
  * explícito (`{ OrgModel, MemberModel, InvitationModel }`) continua valendo como
- * escape hatch — é para quem guarda as tabelas de auth numa conexão/schema
- * próprios (`static connection = 'auth'`), que estes defaults não declaram.
+ * escape hatch; aí a conexão é a que os models do host declaram.
  *
  * Não crie migration para estas tabelas: elas são criadas/atualizadas pelo
  * `schema.autoManage` do authkit.
@@ -65,3 +66,13 @@ export declare const defaultOrganizationModels: {
     readonly MemberModel: typeof AuthOrganizationMember;
     readonly InvitationModel: typeof AuthOrganizationInvitation;
 };
+export type OrganizationModels = {
+    OrgModel: any;
+    MemberModel: any;
+    InvitationModel: any;
+};
+/**
+ * Os models default numa conexão Lucid nomeada (subclasses com `static connection`),
+ * memoizados por conexão. `undefined` → os próprios defaults (conexão primária).
+ */
+export declare function organizationModelsOn(connection: string | undefined): OrganizationModels;

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

@@ -15,10 +15,11 @@ import { BaseModel, column } from '@adonisjs/lucid/orm';
  * pelo `autoManage` sem que o model escrito à mão no host saiba dela, e o
  * sintoma aparece longe da causa.
  *
- * Use com `organizationModels: true` em {@link lucidAccountStore}. O caminho
+ * Use com `organizationModels: true` em {@link lucidAccountStore}. Eles seguem a
+ * conexão das tabelas do authkit (`schema.connection` do `defineConfig`, como
+ * todas as tabelas lib-owned — ver {@link organizationModelsOn}). O caminho
  * explícito (`{ OrgModel, MemberModel, InvitationModel }`) continua valendo como
- * escape hatch — é para quem guarda as tabelas de auth numa conexão/schema
- * próprios (`static connection = 'auth'`), que estes defaults não declaram.
+ * escape hatch; aí a conexão é a que os models do host declaram.
  *
  * Não crie migration para estas tabelas: elas são criadas/atualizadas pelo
  * `schema.autoManage` do authkit.
@@ -111,3 +112,30 @@ export const defaultOrganizationModels = {
     MemberModel: AuthOrganizationMember,
     InvitationModel: AuthOrganizationInvitation,
 };
+const modelsByConnection = new Map();
+/**
+ * Os models default numa conexão Lucid nomeada (subclasses com `static connection`),
+ * memoizados por conexão. `undefined` → os próprios defaults (conexão primária).
+ */
+export function organizationModelsOn(connection) {
+    if (!connection)
+        return defaultOrganizationModels;
+    let models = modelsByConnection.get(connection);
+    if (!models) {
+        class OrgModel extends AuthOrganization {
+            static table = 'auth_organizations';
+            static connection = connection;
+        }
+        class MemberModel extends AuthOrganizationMember {
+            static table = 'auth_organization_members';
+            static connection = connection;
+        }
+        class InvitationModel extends AuthOrganizationInvitation {
+            static table = 'auth_organization_invitations';
+            static connection = connection;
+        }
+        models = { OrgModel, MemberModel, InvitationModel };
+        modelsByConnection.set(connection, models);
+    }
+    return models;
+}

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

@@ -1,7 +1,7 @@
 import type { OrganizationsCapability } from '../account_store.js';
 /**
- * Contexto mínimo para o builder de organizations. Recebe os três models direto
- * (já construídos pelo lucidAccountStore).
+ * Contexto mínimo para o builder de organizations. Os três models são lidos a cada
+ * uso (podem ser getters — ver `lucidAccountStore`).
  */
 export interface OrgStoreContext {
     OrgModel: any;

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

@@ -59,7 +59,10 @@ async function countOwners(MemberModel, orgId) {
     return Number(result[0]?.$extras?.total ?? 0);
 }
 export function buildOrganizations(ctx) {
-    const { OrgModel, MemberModel, InvitationModel, findAccountEmail, listAccountIdsInAdminOrder } = ctx;
+    // Os models são lidos do ctx a CADA uso (não desestruturados): o `lucidAccountStore`
+    // troca os models default pelos da conexão das tabelas do authkit quando o
+    // `defineConfig` informa o `schema.connection`, depois de construir o store.
+    const { findAccountEmail, listAccountIdsInAdminOrder } = ctx;
     return {
         ...(listAccountIdsInAdminOrder
             ? {
@@ -73,7 +76,7 @@ export function buildOrganizations(ctx) {
                  * (like `listOrgMembers(orgId).length`).
                  */
                 async listAllOrgsWithMemberCount() {
-                    const memberships = await MemberModel.query();
+                    const memberships = await ctx.MemberModel.query();
                     if (memberships.length === 0)
                         return [];
                     const byAccount = new Map();
@@ -90,7 +93,7 @@ export function buildOrganizations(ctx) {
                     }
                     const accountIds = await listAccountIdsInAdminOrder([...byAccount.keys()]);
                     const orgs = new Map();
-                    for (const org of await findManyChunked(OrgModel, [...memberCount.keys()])) {
+                    for (const org of await findManyChunked(ctx.OrgModel, [...memberCount.keys()])) {
                         orgs.set(String(org.id), org);
                     }
                     const result = [];
@@ -117,7 +120,7 @@ export function buildOrganizations(ctx) {
             : {}),
         async createOrg(input) {
             const { randomUUID } = await import('node:crypto');
-            const org = await OrgModel.create({
+            const org = await ctx.OrgModel.create({
                 id: randomUUID(),
                 name: input.name,
                 slug: input.slug,
@@ -125,7 +128,7 @@ export function buildOrganizations(ctx) {
                 metadata: input.metadata ?? null,
             });
             // Cria a membership do owner automaticamente
-            await MemberModel.create({
+            await ctx.MemberModel.create({
                 id: randomUUID(),
                 organizationId: org.id,
                 accountId: input.ownerAccountId,
@@ -134,22 +137,28 @@ export function buildOrganizations(ctx) {
             return toOrgSummary(org);
         },
         async findOrgById(orgId) {
-            const row = await OrgModel.find(orgId);
+            const row = await ctx.OrgModel.find(orgId);
             return row ? toOrgSummary(row) : null;
         },
+        async findOrgsByIds(orgIds) {
+            const ids = [...new Set(orgIds)];
+            if (ids.length === 0)
+                return [];
+            return (await findManyChunked(ctx.OrgModel, ids)).map(toOrgSummary);
+        },
         async findOrgBySlug(slug) {
-            const row = await OrgModel.query().where('slug', slug).first();
+            const row = await ctx.OrgModel.query().where('slug', slug).first();
             return row ? toOrgSummary(row) : null;
         },
         async listOrgsForAccount(accountId) {
-            const memberships = await MemberModel.query().where('account_id', accountId);
+            const memberships = await ctx.MemberModel.query().where('account_id', accountId);
             if (memberships.length === 0)
                 return [];
             // One query for every org (by primary key, like `find`), instead of one per
             // membership. The result keeps the memberships' order.
             const ids = [...new Set(memberships.map((m) => m.organizationId))];
             const orgs = new Map();
-            for (const org of await OrgModel.findMany(ids))
+            for (const org of await ctx.OrgModel.findMany(ids))
                 orgs.set(String(org.id), org);
             const result = [];
             for (const m of memberships) {
@@ -160,7 +169,7 @@ export function buildOrganizations(ctx) {
             return result;
         },
         async updateOrg(orgId, patch) {
-            const row = await OrgModel.find(orgId);
+            const row = await ctx.OrgModel.find(orgId);
             if (!row)
                 return null;
             if (patch.name !== undefined)
@@ -173,16 +182,16 @@ export function buildOrganizations(ctx) {
             return toOrgSummary(row);
         },
         async deleteOrg(orgId) {
-            const row = await OrgModel.find(orgId);
+            const row = await ctx.OrgModel.find(orgId);
             if (!row)
                 return false;
-            await MemberModel.query().where('organization_id', orgId).delete();
-            await InvitationModel.query().where('organization_id', orgId).delete();
+            await ctx.MemberModel.query().where('organization_id', orgId).delete();
+            await ctx.InvitationModel.query().where('organization_id', orgId).delete();
             await row.delete();
             return true;
         },
         async listOrgMembers(orgId) {
-            const rows = await MemberModel.query().where('organization_id', orgId);
+            const rows = await ctx.MemberModel.query().where('organization_id', orgId);
             return rows.map((r) => ({
                 accountId: r.accountId,
                 email: null, // o caller enriquece com findById se necessário
@@ -193,7 +202,7 @@ export function buildOrganizations(ctx) {
         async addOrgMember(orgId, accountId, role) {
             const { randomUUID } = await import('node:crypto');
             // Upsert: se já existe, atualiza a role
-            const existing = await MemberModel.query()
+            const existing = await ctx.MemberModel.query()
                 .where('organization_id', orgId)
                 .where('account_id', accountId)
                 .first();
@@ -202,11 +211,11 @@ export function buildOrganizations(ctx) {
                 await existing.save();
             }
             else {
-                await MemberModel.create({ id: randomUUID(), organizationId: orgId, accountId, role });
+                await ctx.MemberModel.create({ id: randomUUID(), organizationId: orgId, accountId, role });
             }
         },
         async removeOrgMember(orgId, accountId) {
-            const row = await MemberModel.query()
+            const row = await ctx.MemberModel.query()
                 .where('organization_id', orgId)
                 .where('account_id', accountId)
                 .first();
@@ -214,7 +223,7 @@ export function buildOrganizations(ctx) {
                 return { ok: false, reason: 'not_found' };
             // Invariante: org deve ter sempre >= 1 owner
             if (row.role === 'owner') {
-                const ownerCount = await countOwners(MemberModel, orgId);
+                const ownerCount = await countOwners(ctx.MemberModel, orgId);
                 if (ownerCount <= 1)
                     return { ok: false, reason: 'last_owner' };
             }
@@ -222,7 +231,7 @@ export function buildOrganizations(ctx) {
             return { ok: true };
         },
         async updateOrgMemberRole(orgId, accountId, newRole) {
-            const row = await MemberModel.query()
+            const row = await ctx.MemberModel.query()
                 .where('organization_id', orgId)
                 .where('account_id', accountId)
                 .first();
@@ -230,7 +239,7 @@ export function buildOrganizations(ctx) {
                 return { ok: false, reason: 'not_found' };
             // Invariante: não rebaixa o último owner
             if (row.role === 'owner' && newRole !== 'owner') {
-                const ownerCount = await countOwners(MemberModel, orgId);
+                const ownerCount = await countOwners(ctx.MemberModel, orgId);
                 if (ownerCount <= 1)
                     return { ok: false, reason: 'last_owner' };
             }
@@ -239,7 +248,7 @@ export function buildOrganizations(ctx) {
             return { ok: true };
         },
         async getOrgMembership(orgId, accountId) {
-            const row = await MemberModel.query()
+            const row = await ctx.MemberModel.query()
                 .where('organization_id', orgId)
                 .where('account_id', accountId)
                 .first();
@@ -250,7 +259,7 @@ export function buildOrganizations(ctx) {
             const token = randomBytes(32).toString('hex');
             const tokenHash = createHash('sha256').update(token).digest('hex');
             const expiresAt = DateTime.now().plus({ hours: input.ttlHours });
-            const inv = await InvitationModel.create({
+            const inv = await ctx.InvitationModel.create({
                 id: randomUUID(),
                 organizationId: input.organizationId,
                 email: input.email,
@@ -263,21 +272,21 @@ export function buildOrganizations(ctx) {
             return { invitation: toOrgInvitation(inv), token };
         },
         async findInvitationByTokenHash(tokenHash) {
-            const row = await InvitationModel.query().where('token_hash', tokenHash).first();
+            const row = await ctx.InvitationModel.query().where('token_hash', tokenHash).first();
             return row ? toOrgInvitation(row) : null;
         },
         async listPendingInvitationsForOrg(orgId) {
-            const rows = await InvitationModel.query()
+            const rows = await ctx.InvitationModel.query()
                 .where('organization_id', orgId)
                 .whereNull('accepted_at');
             return rows.map(toOrgInvitation);
         },
         async listPendingInvitationsForEmail(email) {
-            const rows = await InvitationModel.query().where('email', email).whereNull('accepted_at');
+            const rows = await ctx.InvitationModel.query().where('email', email).whereNull('accepted_at');
             return rows.map(toOrgInvitation);
         },
         async acceptInvitation(invitationId, accountId) {
-            const inv = await InvitationModel.find(invitationId);
+            const inv = await ctx.InvitationModel.find(invitationId);
             if (!inv)
                 return { ok: false, reason: 'not_found' };
             // Verifica expiração (expiresAt pode ser DateTime Luxon, Date, ou string do SQLite)
@@ -305,7 +314,7 @@ export function buildOrganizations(ctx) {
                 return { ok: false, reason: 'email_mismatch' };
             }
             // Verifica se já é membro
-            const existing = await MemberModel.query()
+            const existing = await ctx.MemberModel.query()
                 .where('organization_id', inv.organizationId)
                 .where('account_id', accountId)
                 .first();
@@ -317,7 +326,7 @@ export function buildOrganizations(ctx) {
             }
             // Cria membership + marca accepted_at
             const { randomUUID } = await import('node:crypto');
-            await MemberModel.create({
+            await ctx.MemberModel.create({
                 id: randomUUID(),
                 organizationId: inv.organizationId,
                 accountId,
@@ -331,7 +340,7 @@ export function buildOrganizations(ctx) {
             // Escopado por org: exige que o convite pertença à org informada antes de
             // deletar. Sem esse filtro, um owner/admin de qualquer org revogaria
             // convites de outra org sabendo apenas o invitationId (IDOR cross-org).
-            const inv = await InvitationModel.query()
+            const inv = await ctx.InvitationModel.query()
                 .where('id', invitationId)
                 .where('organization_id', organizationId)
                 .first();
@@ -342,7 +351,7 @@ export function buildOrganizations(ctx) {
         },
         async removeAccountFromAllOrgs(accountId) {
             // Memberships: remove todas, mesmo se for único owner (LGPD não pode bloquear)
-            const memberships = await MemberModel.query().where('account_id', accountId);
+            const memberships = await ctx.MemberModel.query().where('account_id', accountId);
             for (const m of memberships) {
                 await m.delete();
             }
@@ -350,7 +359,7 @@ export function buildOrganizations(ctx) {
             const email = await findAccountEmail(accountId);
             let invCount = 0;
             if (email) {
-                const invitations = await InvitationModel.query()
+                const invitations = await ctx.InvitationModel.query()
                     .where('email', email)
                     .whereNull('accepted_at');
                 for (const inv of invitations) {

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

@@ -78,6 +78,12 @@ export interface LucidStoreContext {
      * recovery da conta. Ver nota de `emailVerificationTtlHours`.
      */
     emailChangeTtlHours?: number;
+    /**
+     * Query client for AuthKit's own tables (`auth_mfa`, `auth_password_history`):
+     * `schema.connection` of `defineConfig`, NOT the account model's connection. Absent
+     * → the model's connection (a store used without `defineConfig`).
+     */
+    tablesClient?: () => any;
 }
 export declare const sha256: (value: string) => string;
 /** Recovery code legível: 10 chars hex em duas metades (ex.: a1b2c-3d4e5). */
@@ -105,15 +111,17 @@ export interface MfaStatePatch {
 }
 /**
  * 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.
+ * `account_id`. Acessa o banco pela conexão das tabelas do authkit
+ * (`schema.connection`, via `tablesClient`), a mesma em que o `autoManage` cria a
+ * tabela — sem exigir migration no host. Sem `tablesClient` (store fora do
+ * `defineConfig`), cai na conexão do model.
  *
  * 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 declare function buildMfaStateRepo(Model: any): {
+export declare function buildMfaStateRepo(Model: any, tablesClient?: () => any): {
     /** Lê o estado de MFA da conta; null se não há linha em `auth_mfa`. */
     read(accountId: string): Promise<MfaState | null>;
     /**

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

@@ -39,19 +39,21 @@ export function hashesEqual(a, b) {
 }
 /**
  * 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.
+ * `account_id`. Acessa o banco pela conexão das tabelas do authkit
+ * (`schema.connection`, via `tablesClient`), a mesma em que o `autoManage` cria a
+ * tabela — sem exigir migration no host. Sem `tablesClient` (store fora do
+ * `defineConfig`), cai na conexão do model.
  *
  * 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) {
+export function buildMfaStateRepo(Model, tablesClient) {
     const TABLE = 'auth_mfa';
-    /** QueryClient ligado à conexão do model (equivale ao `db` do password_history). */
+    /** QueryClient das tabelas do authkit (equivale ao `db` do password_history). */
     function client() {
-        return Model.query().client;
+        return tablesClient ? tablesClient() : Model.query().client;
     }
     /** Normaliza `recovery_codes` vindo do banco (json string OU array já parseado). */
     function parseRecoveryCodes(raw) {

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

@@ -8,7 +8,7 @@ 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);
+    const mfaState = buildMfaStateRepo(Model, ctx.tablesClient);
     return {
         async generatePasskeyRegistrationOptions(accountId) {
             const row = await Model.find(accountId);

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

@@ -1,8 +1,16 @@
 import type { ApplicationService } from '@adonisjs/core/types';
 import type { OidcAdapter } from './adapter_contract.js';
 export type OidcAdapterClass = new (name: string) => OidcAdapter;
+/** What `defineConfig` hands every adapter factory. */
+export interface AdapterResolveContext {
+    /**
+     * `schema.connection` of `defineConfig`: the Lucid connection AuthKit's tables live
+     * on. A database adapter without its own `connection` uses it.
+     */
+    connection?: string;
+}
 export interface AdapterFactory {
-    resolver(app: ApplicationService): Promise<OidcAdapterClass>;
+    resolver(app: ApplicationService, context?: AdapterResolveContext): Promise<OidcAdapterClass>;
 }
 /**
  * Modelos do oidc-provider de vida curta, amarrados ao ciclo da sessão de
@@ -35,7 +43,10 @@ export interface RedisAdapterConfig {
     prefix?: string;
 }
 export interface DatabaseAdapterConfig {
-    /** nome da conexão Lucid (default: a primária) */
+    /**
+     * Nome da conexão Lucid. Default: `schema.connection` do `defineConfig` (a conexão
+     * de todas as tabelas do authkit), e sem ela a primária.
+     */
     connection?: string;
 }
 export declare const adapters: {

package/build/src/adapters/factory.js

@@ -67,9 +67,9 @@ export const adapters = {
      */
     database(config = {}) {
         return {
-            async resolver(app) {
+            async resolver(app, context) {
                 const db = await app.container.make('lucid.db');
-                const connection = config.connection;
+                const connection = config.connection ?? context?.connection;
                 const conn = connection ? db.connection(connection) : db;
                 return class extends DatabaseAdapter {
                     constructor(name) {

package/build/src/agents/config.d.ts

@@ -12,7 +12,7 @@
  * recibos) não depende de protocolo; o formato do fio vem do adapter em
  * `protocol` (default: PACT — https://openpactprotocol.org). Ver `protocol.ts`.
  */
-import { type PoppyConfigInput, type ResolvedPoppyConfig } from './poppy/config.js';
+import { type PersonalAgentExtension, type ResolvedPersonalAgentExtension } from './extension.js';
 import { type BuiltinProtocolId, type PersonalAgentProtocol } from './protocol.js';
 /** Registro de um personal agent conhecido (PACT §3.1). */
 export interface PersonalAgentRegistration {
@@ -58,8 +58,8 @@ export interface PersonalAgentsConfigInput {
     /**
      * Valor que os personal agents põem no `aud` do JWT deles (PACT). Opaco e
      * atribuído por ESTE app no registro do agente — um valor por app, não
-     * derivado de URL. Liga o PACT; obrigatório, a não ser num app só-Poppy
-     * (`poppy` sem `audience`).
+     * derivado de URL. Liga o PACT; obrigatório, a não ser num app que só usa
+     * `extensions` (sem `audience`).
      */
     audience?: string;
     /**
@@ -79,14 +79,10 @@ export interface PersonalAgentsConfigInput {
     /** Prefixo das rotas (`{prefix}/oauth/*`, `{prefix}/consent`). Default: `/agents`. */
     prefix?: string;
     /**
-     * Personal Agent Protocol ("Poppy", https://personalagentprotocol.org) — o
-     * segundo protocolo, ao lado do PACT. Um app pode servir os dois. Ver
-     * `poppy/config.ts`.
-     *
-     * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
-     *   de forma incompatível fora de majors enquanto ela for draft.
+     * Outros protocolos de personal agents, de pacotes à parte, ao lado do PACT
+     * (ex.: `poppy()` de `@adonis-agora/authkit-poppy`). Ver {@link PersonalAgentExtension}.
      */
-    poppy?: PoppyConfigInput;
+    extensions?: PersonalAgentExtension[];
 }
 export interface ResolvedPersonalAgentDelegationConfig {
     interfaceUrl: string;
@@ -108,11 +104,11 @@ export interface ResolvedPersonalAgentsConfig {
     open: boolean;
     delegation?: ResolvedPersonalAgentDelegationConfig;
     prefix: string;
-    /** Poppy resolvido (undefined = desligado). */
-    poppy?: ResolvedPoppyConfig;
+    /** `extensions` resolvidas, na ordem do config. */
+    extensions: ResolvedPersonalAgentExtension[];
 }
 export declare function normalizePersonalAgentsPrefix(prefix: string | undefined): string;
-export declare function resolvePersonalAgentsConfig(input: PersonalAgentsConfigInput | undefined): ResolvedPersonalAgentsConfig | undefined;
+export declare function resolvePersonalAgentsConfig(input: PersonalAgentsConfigInput | undefined, issuer?: string): ResolvedPersonalAgentsConfig | undefined;
 /** `"a b  c"` → `['a','b','c']` sem duplicatas, na ordem. */
 export declare function parseScope(value: string | null | undefined): string[];
 export declare function formatScope(scopes: Iterable<string>): string;