@adonis-agora/authkit-server 0.66.3 → 0.68.0

package/build/index.d.ts

@@ -7,6 +7,7 @@ export type { AccountDeletionCapability, AccountImportCapability, AccountSecurit
 export { supportsAccountDeletion, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
 export type { AccountSecretEncrypter, LucidAccountStoreOptions, } from './src/accounts/lucid_account_store.js';
 export { appKeyEncrypter, lucidAccountStore } from './src/accounts/lucid_account_store.js';
+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 { AuditEvent, AuditEventType, AuditPage, AuditSink, ListAuditParams, StoredAuditEvent, } from './src/audit/audit_sink.js';

package/build/index.js

@@ -5,6 +5,7 @@
 export { configure } from './commands/configure.js';
 export { supportsAccountDeletion, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
 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 { lucidAuditSink } from './src/audit/lucid_audit_sink.js';
 export { adapters, defineConfig, resolveAdmin, resolveAdminApi, resolveAuthMethodsConfig, resolveDynamicRegistration, resolveLogin, resolveNotifications, resolveOrganizations, resolvePasswordless, resolveRateLimit, resolveRegistration, resolveWebauthn, toSeconds, } from './src/define_config.js';

package/build/providers/authkit_server_provider.js

@@ -218,7 +218,10 @@ export default class AuthkitServerProvider {
             if (!db)
                 return; // host sem @adonisjs/lucid — nada a gerenciar
             const { ensureAuthkitSchema } = await import('../src/schema/ensure.js');
-            const report = await ensureAuthkitSchema(db, { connection: config.schema.connection });
+            const report = await ensureAuthkitSchema(db, {
+                connection: config.schema.connection,
+                accountTable: config.accountStore?.accountTable,
+            });
             const logger = await this.app.container.make('logger').catch(() => null);
             if (report.created.length > 0) {
                 logger?.info('authkit: created tables %s', report.created.join(', '));
@@ -226,6 +229,13 @@ export default class AuthkitServerProvider {
             for (const [table, columns] of Object.entries(report.altered)) {
                 logger?.info('authkit: added columns to %s: %s', table, columns.join(', '));
             }
+            if (!report.loginMethods.ensured) {
+                // Sem este aviso o host não tinha como saber: a coluna não foi criada e a
+                // preferência de método de login por conta fica no-op em silêncio.
+                logger?.warn('authkit: tabela da conta "%s" não existe — a coluna `login_methods` não foi ' +
+                    'garantida e a preferência de método de login por conta não vai funcionar. ' +
+                    'Defina `accountStore.accountTable` (ou crie a tabela) se o nome estiver errado.', report.loginMethods.table);
+            }
         }
         catch (error) {
             const logger = await this.app.container.make('logger').catch(() => null);

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

@@ -627,6 +627,20 @@ export type AccountStore = CoreAccountStore & {
      * blocos `Partial<...>` de capacidades probáveis.
      */
     readonly connectionName?: string;
+    /**
+     * Nome da tabela da conta (deriva de `Model.table` — e, se o model ainda não
+     * bootou, da naming strategy; ver `lucid_account_store.ts`). Mesmo espírito do
+     * {@link AccountStore.connectionName}: metadado opcional, não método de
+     * capacidade.
+     *
+     * Existe porque a coluna opcional `login_methods` é garantida no boot pelo
+     * `ensureAuthkitSchema`, e ele precisa saber em QUAL tabela ela pertence. Sem
+     * este metadado só resta assumir `users`, e aí uma conta cuja tabela tem outro
+     * nome (por exemplo `auth_users`, que é o que o scaffold da lib usa) fica com
+     * a coluna numa tabela que ninguém consulta — sem erro, sem aviso.
+     * Undefined → `users` (back-compat com stores próprios).
+     */
+    readonly accountTable?: string;
 } & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability & AccountSecurityCapability & AccountStatusCapability & ProfileCapability & MagicLinkCapability & OtpLoginCapability & EmailVerificationStatusCapability & AccountDeletionCapability & AccountImportCapability & OrganizationsCapability & PasswordHistoryCapability & PasswordExpirationCapability & LoginMethodsPreferenceCapability>;
 /** Type guard: o store implementa a capacidade de MFA / TOTP. */
 export declare function supportsMfa(store: AccountStore): store is AccountStore & MfaCapability;

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

@@ -136,12 +136,29 @@ export interface LucidAccountStoreOptions {
      */
     pwnedFetch?: FetchLike;
     /**
-     * Models Lucid para organizations (multi-tenancy). Quando os três forem fornecidos,
-     * a capacidade `OrganizationsCapability` fica disponível no store. Os models devem
-     * ser tabelas `auth_organizations`, `auth_organization_members` e
-     * `auth_organization_invitations`. Ausente → capability AUSENTE (sem tabelas = desligado).
+     * Models Lucid para organizations (multi-tenancy).
+     *
+     * - **Ausente (default)** → usa os models DEFAULT da lib
+     *   ({@link defaultOrganizationModels}), que já mapeiam as três tabelas
+     *   lib-owned (`auth_organizations`, `auth_organization_members`,
+     *   `auth_organization_invitations`). A `OrganizationsCapability` passa a
+     *   existir por padrão. Isso é seguro porque as rotas do console de conta para
+     *   orgs JÁ eram montadas por default (`register_auth_host`, bloco `if
+     *   (mountOrgs)`, com controller capability-probed); antes, sem os models, a
+     *   tela montada respondia 403; agora ela funciona. Não há tela nova — só uma
+     *   que deixou de estar quebrada. As tabelas são criadas/evoluídas pelo
+     *   `ensureAuthkitSchema`, então o mapeamento não é decisão do host.
+     * - `true` → idêntico ao default (atalho explícito; é o que apps existentes
+     *   já usam e continua valendo).
+     * - `{ OrgModel, MemberModel, InvitationModel }` → escape hatch, para quem
+     *   guarda as tabelas de auth numa conexão/schema próprios (os defaults não
+     *   declaram `static connection`).
+     * - `false` → opt-out explícito: `OrganizationsCapability` AUSENTE no store.
+     *   Use quando a dependência atual é `supportsOrganizations === false` (ex.:
+     *   store/rotas que assumem a ausência). O `authkit:doctor` avisa se
+     *   `organizations.enabled: true` e o store não tem a capability.
      */
-    organizationModels?: {
+    organizationModels?: true | false | {
         OrgModel: any;
         MemberModel: any;
         InvitationModel: any;
@@ -153,23 +170,6 @@ export interface LucidAccountStoreOptions {
      */
     emailTokens?: EmailTokensConfigInput;
 }
-/**
- * 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).
- *
- * @remarks Para capabilities que dependem de tabelas opcionais (ex.:
- *   `auth_password_history`), use {@link lucidAccountStoreAsync} que probe o DB
- *   e monta o store já com as capabilities detectadas, sem a necessidade de
- *   fornecer um model separado. A versão síncrona (`lucidAccountStore`) é mantida
- *   por back-compat — capabilities de tabela ficam AUSENTES nela.
- */
 export declare function lucidAccountStore(Model: any, options?: LucidAccountStoreOptions): AccountStore;
 /**
  * Options estendidas para uso em testes ou quando o DB é injetado diretamente

package/build/src/accounts/lucid_account_store.js

@@ -3,6 +3,7 @@ import { PasswordManager } from '../password/password_manager.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 { buildOrganizations } from './lucid_store/organizations.js';
 import { buildPasswordExpiration, buildPasswordHistory } from './lucid_store/password_hygiene.js';
 import { buildProviderIdentity } from './lucid_store/provider_identity.js';
@@ -103,23 +104,24 @@ export function appKeyEncrypter() {
         },
     };
 }
-/**
- * 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).
- *
- * @remarks Para capabilities que dependem de tabelas opcionais (ex.:
- *   `auth_password_history`), use {@link lucidAccountStoreAsync} que probe o DB
- *   e monta o store já com as capabilities detectadas, sem a necessidade de
- *   fornecer um model separado. A versão síncrona (`lucidAccountStore`) é mantida
- *   por back-compat — capabilities de tabela ficam AUSENTES nela.
- */
+function resolveAccountTable(Model) {
+    try {
+        if (typeof Model?.table === 'string' && Model.table.length > 0) {
+            return Model.table;
+        }
+        const naming = Model?.namingStrategy;
+        if (naming && typeof naming.tableName === 'function') {
+            const resolved = naming.tableName(Model);
+            if (typeof resolved === 'string' && resolved.length > 0) {
+                return resolved;
+            }
+        }
+    }
+    catch {
+        // Model ainda não pronto (ou não-Lucid) — metadado é opcional.
+    }
+    return undefined;
+}
 export function lucidAccountStore(Model, options = {}) {
     const mfaIssuer = options.mfaIssuer ?? 'AuthKit';
     const recoveryCodeCount = options.recoveryCodeCount ?? 8;
@@ -128,7 +130,15 @@ export function lucidAccountStore(Model, options = {}) {
     const encrypter = options.encrypter === false ? undefined : (options.encrypter ?? appKeyEncrypter());
     const ProviderIdentityModel = options.providerIdentityModel;
     const WebauthnCredentialModel = options.webauthnCredentialModel;
-    const OrgModels = options.organizationModels;
+    // Organizations é padrão: ausente OU `true` → models default da lib. O
+    // 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;
     // RP do WebAuthn: usado nas cerimônias. Default do rpName cai no mfaIssuer.
     const webauthn = options.webauthn ?? {
         rpName: mfaIssuer,
@@ -199,6 +209,10 @@ export function lucidAccountStore(Model, options = {}) {
     const store = {
         ...buildCore(ctx),
         ...buildMfa(ctx),
+        // Metadado (não capacidade): a tabela da conta, para o ensure da coluna
+        // `login_methods` e o doctor saberem onde ela pertence em vez de assumir
+        // `users`. Ver `resolveAccountTable`.
+        accountTable: resolveAccountTable(Model),
         ...(ProviderIdentityModel ? buildProviderIdentity(ctx, ProviderIdentityModel) : {}),
         ...(WebauthnCredentialModel
             ? buildWebauthn(ctx, WebauthnCredentialModel, webauthn, ceremonies)
@@ -216,17 +230,23 @@ export function lucidAccountStore(Model, options = {}) {
         // Preferência por usuário de tipos de login: só quando o model tem a coluna
         // `login_methods` (JSONB). Sem a coluna → capacidade ausente (feature no-op).
         ...(supportsLoginMethodsColumn(Model) ? buildLoginMethods(ctx) : {}),
-        // Organizations (multi-tenancy): só quando os três models foram fornecidos.
+        // Organizations (multi-tenancy): por padrão usa os models default da lib;
+        // ausente só com `organizationModels: false` (opt-out explícito).
         ...(OrgModels
-            ? buildOrganizations({
-                OrgModel: OrgModels.OrgModel,
-                MemberModel: OrgModels.MemberModel,
-                InvitationModel: OrgModels.InvitationModel,
-                findAccountEmail: async (accountId) => {
-                    const row = await Model.find(accountId);
-                    return row?.email ?? null;
-                },
-            })
+            ? {
+                // Origem dos models, para o `authkit:doctor` reportar sem re-inferir.
+                // NÃO faz parte do contrato AccountStore.
+                __organizationModelsSource: usesDefaultOrgModels ? 'default' : 'explicit',
+                ...buildOrganizations({
+                    OrgModel: OrgModels.OrgModel,
+                    MemberModel: OrgModels.MemberModel,
+                    InvitationModel: OrgModels.InvitationModel,
+                    findAccountEmail: async (accountId) => {
+                        const row = await Model.find(accountId);
+                        return row?.email ?? null;
+                    },
+                }),
+            }
             : {}),
         // Config de senha resolvida — exposta (não-enumerável) para o authkit:doctor
         // inspecionar policy/checkPwned. NÃO faz parte do contrato AccountStore.

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

@@ -0,0 +1,67 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+import type { DateTime } from 'luxon';
+/**
+ * Models default das três tabelas de organizations.
+ *
+ * Estas tabelas são LIB-OWNED: quem as cria e evolui é o `ensureAuthkitSchema`
+ * (ver `TABLES` em `src/schema/ensure.ts`). Exigir que cada host reescrevesse
+ * este mapeamento à mão rendia duas coisas ruins — boilerplate sem nenhuma
+ * decisão do host, e drift silencioso: uma coluna nova nestas tabelas chega
+ * 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
+ * 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.
+ *
+ * Não crie migration para estas tabelas: elas são criadas/atualizadas pelo
+ * `schema.autoManage` do authkit.
+ */
+export declare class AuthOrganization extends BaseModel {
+    static table: string;
+    /** Os ids são sempre fornecidos pelo builder (randomUUID) — nunca pelo banco. */
+    static selfAssignPrimaryKey: boolean;
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    /**
+     * Coluna `json`. O contrato público (`OrgSummary.metadata`) já é
+     * `Record<string, unknown> | null`, e é o que o builder grava/lê — declarar o
+     * mesmo aqui mantém o model alinhado ao que a lib promete.
+     */
+    metadata: Record<string, unknown> | null;
+    createdAt: DateTime | null;
+    updatedAt: DateTime | null;
+}
+export declare class AuthOrganizationMember extends BaseModel {
+    static table: string;
+    static selfAssignPrimaryKey: boolean;
+    id: string;
+    organizationId: string;
+    accountId: string;
+    role: string;
+    createdAt: DateTime | null;
+    updatedAt: DateTime | null;
+}
+export declare class AuthOrganizationInvitation extends BaseModel {
+    static table: string;
+    static selfAssignPrimaryKey: boolean;
+    id: string;
+    organizationId: string;
+    email: string;
+    role: string;
+    tokenHash: string;
+    invitedBy: string;
+    expiresAt: DateTime;
+    acceptedAt: DateTime | null;
+    createdAt: DateTime | null;
+    updatedAt: DateTime | null;
+}
+/** O trio que {@link lucidAccountStore} aceita em `organizationModels: true`. */
+export declare const defaultOrganizationModels: {
+    readonly OrgModel: typeof AuthOrganization;
+    readonly MemberModel: typeof AuthOrganizationMember;
+    readonly InvitationModel: typeof AuthOrganizationInvitation;
+};

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

@@ -0,0 +1,113 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseModel, column } from '@adonisjs/lucid/orm';
+/**
+ * Models default das três tabelas de organizations.
+ *
+ * Estas tabelas são LIB-OWNED: quem as cria e evolui é o `ensureAuthkitSchema`
+ * (ver `TABLES` em `src/schema/ensure.ts`). Exigir que cada host reescrevesse
+ * este mapeamento à mão rendia duas coisas ruins — boilerplate sem nenhuma
+ * decisão do host, e drift silencioso: uma coluna nova nestas tabelas chega
+ * 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
+ * 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.
+ *
+ * Não crie migration para estas tabelas: elas são criadas/atualizadas pelo
+ * `schema.autoManage` do authkit.
+ */
+export class AuthOrganization extends BaseModel {
+    static table = 'auth_organizations';
+    /** Os ids são sempre fornecidos pelo builder (randomUUID) — nunca pelo banco. */
+    static selfAssignPrimaryKey = true;
+}
+__decorate([
+    column({ isPrimary: true })
+], AuthOrganization.prototype, "id", void 0);
+__decorate([
+    column()
+], AuthOrganization.prototype, "name", void 0);
+__decorate([
+    column()
+], AuthOrganization.prototype, "slug", void 0);
+__decorate([
+    column()
+], AuthOrganization.prototype, "logoUrl", void 0);
+__decorate([
+    column()
+], AuthOrganization.prototype, "metadata", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], AuthOrganization.prototype, "createdAt", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true, autoUpdate: true })
+], AuthOrganization.prototype, "updatedAt", void 0);
+export class AuthOrganizationMember extends BaseModel {
+    static table = 'auth_organization_members';
+    static selfAssignPrimaryKey = true;
+}
+__decorate([
+    column({ isPrimary: true })
+], AuthOrganizationMember.prototype, "id", void 0);
+__decorate([
+    column()
+], AuthOrganizationMember.prototype, "organizationId", void 0);
+__decorate([
+    column()
+], AuthOrganizationMember.prototype, "accountId", void 0);
+__decorate([
+    column()
+], AuthOrganizationMember.prototype, "role", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], AuthOrganizationMember.prototype, "createdAt", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true, autoUpdate: true })
+], AuthOrganizationMember.prototype, "updatedAt", void 0);
+export class AuthOrganizationInvitation extends BaseModel {
+    static table = 'auth_organization_invitations';
+    static selfAssignPrimaryKey = true;
+}
+__decorate([
+    column({ isPrimary: true })
+], AuthOrganizationInvitation.prototype, "id", void 0);
+__decorate([
+    column()
+], AuthOrganizationInvitation.prototype, "organizationId", void 0);
+__decorate([
+    column()
+], AuthOrganizationInvitation.prototype, "email", void 0);
+__decorate([
+    column()
+], AuthOrganizationInvitation.prototype, "role", void 0);
+__decorate([
+    column()
+], AuthOrganizationInvitation.prototype, "tokenHash", void 0);
+__decorate([
+    column()
+], AuthOrganizationInvitation.prototype, "invitedBy", void 0);
+__decorate([
+    column.dateTime()
+], AuthOrganizationInvitation.prototype, "expiresAt", void 0);
+__decorate([
+    column.dateTime()
+], AuthOrganizationInvitation.prototype, "acceptedAt", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], AuthOrganizationInvitation.prototype, "createdAt", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true, autoUpdate: true })
+], AuthOrganizationInvitation.prototype, "updatedAt", void 0);
+/** O trio que {@link lucidAccountStore} aceita em `organizationModels: true`. */
+export const defaultOrganizationModels = {
+    OrgModel: AuthOrganization,
+    MemberModel: AuthOrganizationMember,
+    InvitationModel: AuthOrganizationInvitation,
+};

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

@@ -14,8 +14,16 @@ export interface LucidStoresModels {
     providerIdentity?: any;
     /** Model de `withWebauthnCredential()` — habilita passkeys. */
     webauthnCredential?: any;
-    /** Trio de models de organizations — habilita multi-tenancy. */
-    organizations?: {
+    /**
+     * Organizations (multi-tenancy) — habilita a `OrganizationsCapability`.
+     *
+     * **Ausente → ligada por padrão** (models default da lib; as três tabelas são
+     * lib-owned, criadas pelo `ensureAuthkitSchema`). `true` é o atalho explícito
+     * para o mesmo caminho; `false` é o opt-out (capability ausente). O trio
+     * explícito fica como escape hatch para quem guarda as tabelas de auth numa
+     * conexão/schema próprios.
+     */
+    organizations?: true | false | {
         OrgModel: any;
         MemberModel: any;
         InvitationModel: any;
@@ -37,9 +45,14 @@ export type LucidStoresOptions = Omit<LucidAccountStoreOptions, 'providerIdentit
  * const { accountStore, patStore, audit } = lucidStores(
  *   { account: AuthUser, pat: PersonalAccessToken, audit: AuditLog,
  *     providerIdentity: ProviderIdentity, webauthnCredential: WebauthnCredential,
- *     organizations: { OrgModel: Organization, MemberModel: OrganizationMember, InvitationModel: OrganizationInvitation } },
+ *     organizations: true },
  *   { mfaIssuer: 'educ(a)ção', webauthn }
  * )
  * ```
+ *
+ * Organizations é ligada por padrão (models default da lib); `organizations:
+ * false` desliga. Se as tabelas de auth vivem numa conexão/schema próprios, passe
+ * o trio explícito (`{ OrgModel, MemberModel, InvitationModel }`) — os defaults
+ * não declaram `static connection`.
  */
 export declare function lucidStores(models: LucidStoresModels, options?: LucidStoresOptions): LucidStoresResult;

package/build/src/accounts/lucid_stores.js

@@ -10,10 +10,15 @@ import { lucidAccountStore } from './lucid_account_store.js';
  * const { accountStore, patStore, audit } = lucidStores(
  *   { account: AuthUser, pat: PersonalAccessToken, audit: AuditLog,
  *     providerIdentity: ProviderIdentity, webauthnCredential: WebauthnCredential,
- *     organizations: { OrgModel: Organization, MemberModel: OrganizationMember, InvitationModel: OrganizationInvitation } },
+ *     organizations: true },
  *   { mfaIssuer: 'educ(a)ção', webauthn }
  * )
  * ```
+ *
+ * Organizations é ligada por padrão (models default da lib); `organizations:
+ * false` desliga. Se as tabelas de auth vivem numa conexão/schema próprios, passe
+ * o trio explícito (`{ OrgModel, MemberModel, InvitationModel }`) — os defaults
+ * não declaram `static connection`.
  */
 export function lucidStores(models, options = {}) {
     const accountStore = lucidAccountStore(models.account, {

package/build/src/doctor/checks.d.ts

@@ -119,7 +119,11 @@ export declare function checkAccessTokens(input: DoctorInput): Finding | null;
 /**
  * Organizations (multi-tenancy). Informa se a capacidade está disponível
  * (store expõe createOrg) e avisa se `organizations.enabled: true` no config mas
- * a capacidade não está presente no store (organizationModels não foram passados).
+ * a capacidade não está presente no store.
+ *
+ * Com `lucidAccountStore()`, a capability existe POR PADRÃO (models default da
+ * lib); o aviso abaixo só é alcançável para store não-lucid que não a implementa
+ * ou para um store lucid construído com `organizationModels: false` (opt-out).
  */
 export declare function checkOrganizations(input: DoctorInput): Finding | null;
 /**

package/build/src/doctor/checks.js

@@ -488,7 +488,11 @@ export function checkAccessTokens(input) {
 /**
  * Organizations (multi-tenancy). Informa se a capacidade está disponível
  * (store expõe createOrg) e avisa se `organizations.enabled: true` no config mas
- * a capacidade não está presente no store (organizationModels não foram passados).
+ * a capacidade não está presente no store.
+ *
+ * Com `lucidAccountStore()`, a capability existe POR PADRÃO (models default da
+ * lib); o aviso abaixo só é alcançável para store não-lucid que não a implementa
+ * ou para um store lucid construído com `organizationModels: false` (opt-out).
  */
 export function checkOrganizations(input) {
     const cfg = input.authkitConfig;
@@ -501,15 +505,26 @@ export function checkOrganizations(input) {
         return {
             level: 'warn',
             message: 'organizations.enabled: true, but the accountStore has no OrganizationsCapability — ' +
-                'pass `organizationModels: { OrgModel, MemberModel, InvitationModel }` to `lucidAccountStore()`. ' +
-                'Expected tables: auth_organizations, auth_organization_members, auth_organization_invitations.',
+                'with `lucidAccountStore()` it is present by default; if you passed ' +
+                '`organizationModels: false`, drop the opt-out (or pass the explicit ' +
+                '`{ OrgModel, MemberModel, InvitationModel }` trio when the auth tables live on their ' +
+                'own connection/schema). Expected tables: auth_organizations, ' +
+                'auth_organization_members, auth_organization_invitations.',
         };
     }
     if (storeSupports) {
         const roles = cfg.organizations?.roles ?? ['owner', 'admin', 'member'];
+        // Origem dos models: default da lib (organizationModels ausente/true) ou
+        // trio explícito do host. Ausente em store não-lucid → wording genérica.
+        const source = store.__organizationModelsSource;
+        const models = source === 'default'
+            ? 'lib defaults (organizationModels omitted or true)'
+            : source === 'explicit'
+                ? 'host-provided explicit trio'
+                : 'lib defaults or host-provided models';
         return {
             level: 'ok',
-            message: `organizations capability present (roles: ${roles.join(', ')}).`,
+            message: `organizations capability present (models: ${models}; roles: ${roles.join(', ')}).`,
         };
     }
     // Auto mode (enabled === undefined) and store doesn't support — silently ok (opt-in).

package/build/src/schema/ensure.d.ts

@@ -26,12 +26,28 @@
 export interface EnsureSchemaOptions {
     /** Conexão Lucid a usar. Default: conexão primária. */
     connection?: string;
+    /**
+     * Tabela da conta, onde a coluna opcional `login_methods` pertence. Vem do
+     * metadado `accountStore.accountTable` (o provider repassa no boot). Undefined
+     * → `users`, que era o único valor possível antes deste metadado existir.
+     */
+    accountTable?: string;
 }
 export interface EnsureSchemaReport {
     /** Tabelas criadas do zero nesta execução. */
     created: string[];
     /** Colunas adicionadas em tabelas já existentes: tabela → colunas. */
     altered: Record<string, string[]>;
+    /**
+     * Desfecho da coluna `login_methods`. `ensured: false` significa que a tabela
+     * da conta não existe no banco, então NADA foi feito — e é o caso que
+     * silenciava o problema: o host precisa saber que a preferência de método de
+     * login não vai funcionar até a tabela existir.
+     */
+    loginMethods: {
+        table: string;
+        ensured: boolean;
+    };
 }
 /**
  * Garante que as tabelas do authkit existem e têm todas as colunas que esta

package/build/src/schema/ensure.js

@@ -234,7 +234,11 @@ async function columnExists(conn, table, column) {
  */
 export async function ensureAuthkitSchema(db, options = {}) {
     const conn = options.connection ? db.connection(options.connection) : db.connection();
-    const report = { created: [], altered: {} };
+    const report = {
+        created: [],
+        altered: {},
+        loginMethods: { table: options.accountTable ?? 'users', ensured: false },
+    };
     for (const def of TABLES) {
         if (!(await tableExists(conn, def.name))) {
             try {
@@ -260,29 +264,48 @@ export async function ensureAuthkitSchema(db, options = {}) {
             report.altered[def.name].push(column);
         }
     }
-    // Coluna `login_methods` em `auth.users` — a tabela é HOST-owned (não está em
-    // TABLES porque o nome/shape são decisão do app), mas a LI B consome a coluna
-    // (LoginMethodsPreferenceCapability). Alguns deploys de host só migram o schema
-    // do domínio, não o schema `auth` — então a migration manual da coluna pode
-    // nunca rodar, e isso derrubava TODO login/callback OIDC com "column users.login_methods
-    // does not exist" no instante em que o model passou a declará-la.
-    // Aqui garantimos: SE `auth.users` existe E a coluna falta, adicionamos. Nunca
-    // criamos a tabela (host-owned). Aditivo + idempotente — roda em todo boot.
-    try {
-        if (await tableExists(conn, 'users')) {
-            if (!(await columnExists(conn, 'users', 'login_methods'))) {
-                await conn.schema.alterTable('users', (t) => {
+    // Coluna `login_methods` na tabela da CONTA — a tabela é HOST-owned (não está
+    // em TABLES porque o nome/shape são decisão do app), mas a LIB consome a
+    // coluna (LoginMethodsPreferenceCapability). Alguns deploys de host só migram
+    // o schema do domínio, não o schema de auth — então a migration manual da
+    // coluna pode nunca rodar, e isso derrubava TODO login/callback OIDC com
+    // "column ...login_methods does not exist" no instante em que o model passou a
+    // declará-la.
+    //
+    // Aqui garantimos: SE a tabela da conta existe E a coluna falta, adicionamos.
+    // Nunca criamos a tabela (host-owned). Aditivo + idempotente — roda em todo boot.
+    //
+    // O nome da tabela vem do store (`accountStore.accountTable`), NÃO de um
+    // `users` fixo: com a conta em `auth_users` (o nome que o próprio scaffold da
+    // lib usa), o `users` fixo acertava uma tabela qualquer de mesmo nome e a
+    // coluna ia parar no lugar errado sem erro nenhum.
+    const accountTable = options.accountTable ?? 'users';
+    if (await tableExists(conn, accountTable)) {
+        try {
+            if (!(await columnExists(conn, accountTable, 'login_methods'))) {
+                await conn.schema.alterTable(accountTable, (t) => {
                     t.jsonb('login_methods').nullable();
                 });
-                report.altered.users = ['login_methods'];
+                report.altered[accountTable] = ['login_methods'];
             }
+            report.loginMethods.ensured = true;
         }
-    }
-    catch (error) {
-        // Tabela host-owned pode não existir num banco que nunca criou users — não
-        // é erro: fail-soft (a migração do host cuida). Nunca criar a tabela aqui.
-        if (!(await tableExists(conn, 'users'))) {
-            throw error; // alguém criou entre o probe e o ALTER — repropaga se sumiu
+        catch (error) {
+            /**
+             * Corrida entre instâncias subindo juntas: se a coluna já existe agora,
+             * outra ganhou o ALTER — segue o jogo. Qualquer outra falha PROPAGA.
+             *
+             * O re-probe tem de ser da COLUNA, não da tabela: checar a tabela fazia um
+             * ALTER que falhou virar `ensured: true`, ou seja, o report dizia sucesso e
+             * o boot não avisava nada — o silêncio que este bloco existe para acabar.
+             * (Mesma semântica do probe de `createTable` logo acima.)
+             */
+            if (await columnExists(conn, accountTable, 'login_methods')) {
+                report.loginMethods.ensured = true;
+            }
+            else {
+                throw error;
+            }
         }
     }
     return report;

package/build/stubs/config/authkit_react.stub

@@ -3,7 +3,7 @@
 }}}
 import env from '#start/env'
 import AuthUser from '#models/auth_user'
-import { defineConfig, adapters, inertiaRenderer } from '@adonis-agora/authkit-server'
+import { defineConfig, adapters, lucidAccountStore, inertiaRenderer } from '@adonis-agora/authkit-server'
 
 const authServerConfig = defineConfig({
   issuer: env.get('AUTHKIT_ISSUER'),
@@ -14,18 +14,9 @@ const authServerConfig = defineConfig({
   ],
   ttl: { accessToken: '15m', refreshToken: '30d' },
   globalRolesClaim: 'roles',
-  findAccount: async (sub) => {
-    const user = await AuthUser.find(sub)
-    if (!user) return null
-    return { id: user.id, email: user.email, globalRoles: user.globalRoles }
-  },
-  verifyCredentials: async (email, password) => {
-    const user = await AuthUser.query().where('email', email).first()
-    if (!user || !(await user.verifyPassword(password))) return null
-    return { id: user.id }
-  },
+  accountStore: lucidAccountStore(AuthUser),
   /**
-   * Renderer Inertia/React: apenas as views listadas em `views` vão ao Inertia;
+   * Renderer Inertia/React: apenas as views listadas em "views" vão ao Inertia;
    * as demais (incluindo todas as telas admin/*) recaem silenciosamente no
    * renderer Edge built-in da lib — evitando SSR crash por página inexistente.
    *

package/build/stubs/migrations/create_auth_users_table.stub

@@ -11,10 +11,10 @@ export default class extends BaseSchema {
   async up() {
     this.schema.createTable(this.tableName, (table) => {
       /**
-       * String, NÃO increments(): o hook `@beforeCreate` do model scaffoldado
-       * (`models/auth_user.stub`) atribui um `randomUUID()` antes do insert.
+       * String, NÃO increments(): o hook @beforeCreate do model scaffoldado
+       * (models/auth_user.stub) atribui um randomUUID() antes do insert.
        * Uma coluna auto-increment aceitaria o INSERT mesmo assim, mas o valor
-       * do UUID seria descartado e o `id` do model voltaria como o rowid
+       * do UUID seria descartado e o id do model voltaria como o rowid
        * interno do banco — a conta ficaria inalcançável pelo id real na
        * próxima request. Ver packages/authkit-server/stubs/models/auth_user.stub.
        */
@@ -34,7 +34,7 @@ export default class extends BaseSchema {
 
       // Coluna própria do model scaffoldado (não vem de nenhum mixin): a tela
       // de signup embutida sempre coleta "Nome" e o Lucid store passa esse
-      // valor direto para `AuthUser.create()` — sem esta coluna o primeiro
+      // valor direto para AuthUser.create() — sem esta coluna o primeiro
       // signup quebra com "Cannot define 'fullName' on 'AuthUser' model,
       // since it is not defined as a model property".
       table.string('full_name').nullable()

package/build/stubs/models/auth_user.stub

@@ -20,7 +20,7 @@ import { withAuthUser, withCredentials } from '@adonis-agora/authkit-server'
 export default class AuthUser extends compose(BaseModel, withAuthUser(), withCredentials()) {
   /**
    * Sem isto, o Lucid ignora o id atribuído pelo hook abaixo e sobrescreve
-   * `id` com o retorno bruto do INSERT (o rowid interno do SQLite/Postgres)
+   * id com o retorno bruto do INSERT (o rowid interno do SQLite/Postgres)
    * assim que a linha é salva — mesmo resultado prático de não ter o hook: a
    * conta some do próprio id que acabou de criar.
    */
@@ -31,7 +31,7 @@ export default class AuthUser extends compose(BaseModel, withAuthUser(), withCre
 
   /**
    * Nem withAuthUser() nem withCredentials() geram o id — sem este hook o
-   * Lucid insere NULL nesta coluna string e o `id` do model volta como o
+   * Lucid insere NULL nesta coluna string e o id do model volta como o
    * rowid interno do banco, tornando a conta inalcançável pelo id real na
    * próxima request.
    */
@@ -42,7 +42,7 @@ export default class AuthUser extends compose(BaseModel, withAuthUser(), withCre
 
   /**
    * A tela de signup embutida sempre coleta um campo "Nome", e o Lucid store
-   * passa esse valor direto para `AuthUser.create()` — sem esta coluna o
+   * passa esse valor direto para AuthUser.create() — sem esta coluna o
    * primeiro signup quebra com "Cannot define 'fullName' on 'AuthUser'
    * model, since it is not defined as a model property".
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.66.3",
+  "version": "0.68.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",
@@ -153,6 +153,7 @@
     "react-dom": "19.2.8",
     "react-error-boundary": "6.1.5",
     "recharts": "3.10.1",
+    "tempura": "^0.4.1",
     "typescript": "7.0.2",
     "vite": "8.2.2"
   },

package/skills/authkit-interactions/SKILL.md

@@ -6,7 +6,7 @@ description: >-
   routes every IdP app must register (show/login/consent on AuthInteractionController),
   `node ace configure --ui=edge|react|headless` presets, the shell-controller +
   service.interactions split (details(ctx), login(ctx,{email,password}), consent(ctx)),
-  overriding verifyCredentials in config/authkit.ts, renderers edgeRenderer/inertiaRenderer,
+  overriding accountStore.verifyCredentials in config/authkit.ts, renderers edgeRenderer/inertiaRenderer,
   and end-to-end testing with @adonis-agora/authkit-testing (createTestIdentity,
   mintTestIdToken, serveJwks, fakeAuthenticator). Use when the authorization flow 404s at
   the login screen, wiring custom login UI, plugging an external user base, or testing
@@ -81,24 +81,30 @@ the shell only translates between HTTP and those calls.
 Source: `packages/authkit-server/README.md` § UI de login/consent ("o controller
 ejetado é casca: a lógica vive em `service.interactions`").
 
-### Pattern 2 — plug your user base via `verifyCredentials`
+### Pattern 2 — plug your user base via `accountStore.verifyCredentials`
 
-`verifyCredentials` in `config/authkit.ts` decides whether credentials are valid;
-`service.interactions.login` calls it. The default queries the `AuthUser` model by
-email and uses `verifyPassword` — override to authenticate against anything else:
+`verifyCredentials` on the configured `accountStore` decides whether credentials
+are valid; `service.interactions.login` calls it. The default
+`lucidAccountStore(AuthUser)` queries the `AuthUser` model by email and uses the
+`withCredentials` mixin — override the store method to authenticate against
+anything else (`findAccount`/`verifyCredentials` are NOT top-level `defineConfig`
+keys; `AuthServerConfigInput` accepts only `accountStore`, from which the lib
+derives both):
 
 ```ts
 // config/authkit.ts
 defineConfig({
   issuer: env.get('AUTHKIT_ISSUER'),
   adapter: adapters.redis({ connection: 'main' }),
-  accountStore: lucidAccountStore(AuthUser),
-  verifyCredentials: async (email, password) => {
-    // Return the account on success; throw/falsy paths fail the login.
-    const account = await AuthUser.query().where('email', email).first()
-    if (!account) throw new Error('Invalid credentials')
-    await verifyPassword(account.passwordHash, password)
-    return account
+  accountStore: {
+    ...lucidAccountStore(AuthUser),
+    verifyCredentials: async (email, password) => {
+      // Return the account on success; throw/falsy paths fail the login.
+      const account = await AuthUser.query().where('email', email).first()
+      if (!account) throw new Error('Invalid credentials')
+      await verifyPassword(account.passwordHash, password)
+      return account
+    },
   },
 })
 ```

package/stubs/config/authkit_react.stub

@@ -3,7 +3,7 @@
 }}}
 import env from '#start/env'
 import AuthUser from '#models/auth_user'
-import { defineConfig, adapters, inertiaRenderer } from '@adonis-agora/authkit-server'
+import { defineConfig, adapters, lucidAccountStore, inertiaRenderer } from '@adonis-agora/authkit-server'
 
 const authServerConfig = defineConfig({
   issuer: env.get('AUTHKIT_ISSUER'),
@@ -14,18 +14,9 @@ const authServerConfig = defineConfig({
   ],
   ttl: { accessToken: '15m', refreshToken: '30d' },
   globalRolesClaim: 'roles',
-  findAccount: async (sub) => {
-    const user = await AuthUser.find(sub)
-    if (!user) return null
-    return { id: user.id, email: user.email, globalRoles: user.globalRoles }
-  },
-  verifyCredentials: async (email, password) => {
-    const user = await AuthUser.query().where('email', email).first()
-    if (!user || !(await user.verifyPassword(password))) return null
-    return { id: user.id }
-  },
+  accountStore: lucidAccountStore(AuthUser),
   /**
-   * Renderer Inertia/React: apenas as views listadas em `views` vão ao Inertia;
+   * Renderer Inertia/React: apenas as views listadas em "views" vão ao Inertia;
    * as demais (incluindo todas as telas admin/*) recaem silenciosamente no
    * renderer Edge built-in da lib — evitando SSR crash por página inexistente.
    *

package/stubs/migrations/create_auth_users_table.stub

@@ -11,10 +11,10 @@ export default class extends BaseSchema {
   async up() {
     this.schema.createTable(this.tableName, (table) => {
       /**
-       * String, NÃO increments(): o hook `@beforeCreate` do model scaffoldado
-       * (`models/auth_user.stub`) atribui um `randomUUID()` antes do insert.
+       * String, NÃO increments(): o hook @beforeCreate do model scaffoldado
+       * (models/auth_user.stub) atribui um randomUUID() antes do insert.
        * Uma coluna auto-increment aceitaria o INSERT mesmo assim, mas o valor
-       * do UUID seria descartado e o `id` do model voltaria como o rowid
+       * do UUID seria descartado e o id do model voltaria como o rowid
        * interno do banco — a conta ficaria inalcançável pelo id real na
        * próxima request. Ver packages/authkit-server/stubs/models/auth_user.stub.
        */
@@ -34,7 +34,7 @@ export default class extends BaseSchema {
 
       // Coluna própria do model scaffoldado (não vem de nenhum mixin): a tela
       // de signup embutida sempre coleta "Nome" e o Lucid store passa esse
-      // valor direto para `AuthUser.create()` — sem esta coluna o primeiro
+      // valor direto para AuthUser.create() — sem esta coluna o primeiro
       // signup quebra com "Cannot define 'fullName' on 'AuthUser' model,
       // since it is not defined as a model property".
       table.string('full_name').nullable()

package/stubs/models/auth_user.stub

@@ -20,7 +20,7 @@ import { withAuthUser, withCredentials } from '@adonis-agora/authkit-server'
 export default class AuthUser extends compose(BaseModel, withAuthUser(), withCredentials()) {
   /**
    * Sem isto, o Lucid ignora o id atribuído pelo hook abaixo e sobrescreve
-   * `id` com o retorno bruto do INSERT (o rowid interno do SQLite/Postgres)
+   * id com o retorno bruto do INSERT (o rowid interno do SQLite/Postgres)
    * assim que a linha é salva — mesmo resultado prático de não ter o hook: a
    * conta some do próprio id que acabou de criar.
    */
@@ -31,7 +31,7 @@ export default class AuthUser extends compose(BaseModel, withAuthUser(), withCre
 
   /**
    * Nem withAuthUser() nem withCredentials() geram o id — sem este hook o
-   * Lucid insere NULL nesta coluna string e o `id` do model volta como o
+   * Lucid insere NULL nesta coluna string e o id do model volta como o
    * rowid interno do banco, tornando a conta inalcançável pelo id real na
    * próxima request.
    */
@@ -42,7 +42,7 @@ export default class AuthUser extends compose(BaseModel, withAuthUser(), withCre
 
   /**
    * A tela de signup embutida sempre coleta um campo "Nome", e o Lucid store
-   * passa esse valor direto para `AuthUser.create()` — sem esta coluna o
+   * passa esse valor direto para AuthUser.create() — sem esta coluna o
    * primeiro signup quebra com "Cannot define 'fullName' on 'AuthUser'
    * model, since it is not defined as a model property".
    */