@adonis-agora/authkit-server 0.67.0 → 0.68.1

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

@@ -138,20 +138,27 @@ export interface LucidAccountStoreOptions {
     /**
      * Models Lucid para organizations (multi-tenancy).
      *
-     * - `true` → 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`). É o caminho
-     *   recomendado: as tabelas são criadas/evoluídas pelo `ensureAuthkitSchema`,
-     *   então o mapeamento não é decisão do host.
+     * - **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`).
-     * - Ausente → `OrganizationsCapability` AUSENTE no store. Como as rotas
-     *   `/account/orgs*` são montadas por capability-probing, isso deixa a
-     *   feature desligada — silenciosamente, se o host não olhar o
-     *   `authkit:doctor`.
+     * - `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?: true | {
+    organizationModels?: true | false | {
         OrgModel: any;
         MemberModel: any;
         InvitationModel: any;

package/build/src/accounts/lucid_account_store.js

@@ -130,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 === true ? defaultOrganizationModels : 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,
@@ -222,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_stores.d.ts

@@ -17,12 +17,13 @@ export interface LucidStoresModels {
     /**
      * Organizations (multi-tenancy) — habilita a `OrganizationsCapability`.
      *
-     * `true` usa os models default da lib (as três tabelas são lib-owned, criadas
-     * pelo `ensureAuthkitSchema`), que é o caminho recomendado. O trio explícito
-     * fica como escape hatch para quem guarda as tabelas de auth numa
+     * **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 | {
+    organizations?: true | false | {
         OrgModel: any;
         MemberModel: any;
         InvitationModel: any;
@@ -49,9 +50,9 @@ export type LucidStoresOptions = Omit<LucidAccountStoreOptions, 'providerIdentit
  * )
  * ```
  *
- * `organizations: true` usa os models default da lib. 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`.
+ * 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

@@ -15,10 +15,10 @@ import { lucidAccountStore } from './lucid_account_store.js';
  * )
  * ```
  *
- * `organizations: true` usa os models default da lib. 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`.
+ * 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,17 +505,26 @@ export function checkOrganizations(input) {
         return {
             level: 'warn',
             message: 'organizations.enabled: true, but the accountStore has no OrganizationsCapability — ' +
-                'pass `organizationModels: true` to `lucidAccountStore()` (usa os models default da lib), ' +
-                'ou `{ OrgModel, MemberModel, InvitationModel }` se as tabelas de auth vivem numa ' +
-                'conexão/schema próprios. Expected tables: auth_organizations, ' +
+                '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/host/active_org_cookie.d.ts

@@ -26,3 +26,20 @@ export declare function decodeActiveOrgCookie(value: string | null | undefined):
  * NOTA: o oidc-provider ctx.cookies.get() nunca lança — retorna null se ausente.
  */
 export declare function readActiveOrgFromKoaCtx(koaCtx: any): ActiveOrgInfo | null;
+/**
+ * Normaliza um valor potencialmente vindo de um payload PERSISTIDO (o `activeOrg`
+ * do Grant) para `ActiveOrgInfo`. Retorna null quando a forma não bate — nunca
+ * confiamos num objeto só porque ele veio do banco.
+ */
+export declare function normalizeActiveOrg(value: unknown): ActiveOrgInfo | null;
+/**
+ * Lê a org ativa de um contexto de interaction do HOST (o `HttpContext` do
+ * AdonisJS usado pelas `InteractionActions`).
+ *
+ * No consent a request É do browser, então o cookie está presente — ao contrário
+ * do mint do id_token no `/token` (server-a-servidor, sem cookies). O cookie é
+ * gravado UNSIGNED por `account_orgs_controller.activate` e lido aqui via
+ * `request.cookie` (o MESMO caminho das leituras do console/account API), com
+ * fallback para o caminho Koa caso o contexto recebido seja um ctx Koa.
+ */
+export declare function readActiveOrgFromHostCtx(ctx: unknown): ActiveOrgInfo | null;

package/build/src/host/active_org_cookie.js

@@ -26,6 +26,27 @@ export function decodeActiveOrgCookie(value) {
         return null;
     return { orgId, orgSlug, orgRole };
 }
+/**
+ * Parseia um valor de cookie possivelmente URL-encoded.
+ *
+ * O jar Koa do oidc-provider (`cookies`) devolve o valor COMO ESTÁ no header — sem
+ * URL-decode. Como o host grava o cookie via `response.cookie` (que serializa com
+ * `encodeURIComponent`, transformando os TABs em `%09`), é preciso tentar decodificar.
+ * Tentamos o valor cru primeiro (hosts que gravem sem encode) e o decodificado depois.
+ */
+function parseActiveOrgCookieValue(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const direct = decodeActiveOrgCookie(raw);
+    if (direct)
+        return direct;
+    try {
+        return decodeActiveOrgCookie(decodeURIComponent(raw));
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Lê a org ativa de um contexto Koa (oidc-provider). O oidc-provider usa o Keygrip
  * das `cookieKeys` para assinar os cookies — lemos via `ctx.cookies.get(name, { signed: false })`
@@ -39,9 +60,50 @@ export function decodeActiveOrgCookie(value) {
 export function readActiveOrgFromKoaCtx(koaCtx) {
     try {
         const raw = koaCtx?.cookies?.get?.(ACTIVE_ORG_COOKIE, { signed: false });
-        return decodeActiveOrgCookie(raw);
+        return parseActiveOrgCookieValue(raw);
     }
     catch {
         return null;
     }
 }
+/**
+ * Normaliza um valor potencialmente vindo de um payload PERSISTIDO (o `activeOrg`
+ * do Grant) para `ActiveOrgInfo`. Retorna null quando a forma não bate — nunca
+ * confiamos num objeto só porque ele veio do banco.
+ */
+export function normalizeActiveOrg(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const { orgId, orgSlug, orgRole } = value;
+    if (typeof orgId !== 'string' ||
+        !orgId ||
+        typeof orgSlug !== 'string' ||
+        !orgSlug ||
+        typeof orgRole !== 'string' ||
+        !orgRole) {
+        return null;
+    }
+    return { orgId, orgSlug, orgRole };
+}
+/**
+ * Lê a org ativa de um contexto de interaction do HOST (o `HttpContext` do
+ * AdonisJS usado pelas `InteractionActions`).
+ *
+ * No consent a request É do browser, então o cookie está presente — ao contrário
+ * do mint do id_token no `/token` (server-a-servidor, sem cookies). O cookie é
+ * gravado UNSIGNED por `account_orgs_controller.activate` e lido aqui via
+ * `request.cookie` (o MESMO caminho das leituras do console/account API), com
+ * fallback para o caminho Koa caso o contexto recebido seja um ctx Koa.
+ */
+export function readActiveOrgFromHostCtx(ctx) {
+    try {
+        const raw = ctx?.request?.cookie?.(ACTIVE_ORG_COOKIE);
+        const parsed = parseActiveOrgCookieValue(raw);
+        if (parsed)
+            return parsed;
+    }
+    catch {
+        // contexto sem `request.cookie` — tenta o caminho Koa abaixo
+    }
+    return readActiveOrgFromKoaCtx(ctx);
+}

package/build/src/provider/build_provider.js

@@ -1,5 +1,6 @@
 import * as oidc from 'oidc-provider';
 import { pickModelAdapterClass } from '../adapters/factory.js';
+import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
 import { createDeviceSources } from './device_sources.js';
 import { createLogoutSources } from './logout_sources.js';
 /** Atualiza o holder mutável do TTL de sessão com os valores da setting. */
@@ -117,6 +118,35 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
                 : {}),
         })),
         findAccount: options.findAccount,
+        // Grant REAPROVEITADO (consent já lembrado): o org capturado no primeiro
+        // consent ficaria VELHO se o usuário trocasse de org no console e voltasse a
+        // autenticar sem novo consent. Esta função roda numa request do BROWSER (o
+        // authorize), então relemos o cookie aqui e atualizamos o Grant quando
+        // divergir — inclusive LIMPANDO quando o cookie some (org desativada). Sem
+        // isto o token continuaria emitindo a org antiga até o grant expirar.
+        // Assinatura/default confirmados no fonte instalado: `actions/authorization/
+        // session.js` chama `configuration.loadExistingGrant(ctx)`.
+        loadExistingGrant: async (ctx) => {
+            const grantId = ctx.oidc.result?.consent?.grantId || ctx.oidc.session.grantIdFor(ctx.oidc.client.clientId);
+            if (!grantId)
+                return undefined;
+            const grant = await ctx.oidc.provider.Grant.find(grantId);
+            if (!grant)
+                return undefined;
+            const activeOrg = readActiveOrgFromKoaCtx(ctx);
+            const current = normalizeActiveOrg(grant.activeOrg);
+            const changed = (activeOrg?.orgId ?? null) !== (current?.orgId ?? null) ||
+                (activeOrg?.orgSlug ?? null) !== (current?.orgSlug ?? null) ||
+                (activeOrg?.orgRole ?? null) !== (current?.orgRole ?? null);
+            if (changed) {
+                if (activeOrg)
+                    grant.activeOrg = activeOrg;
+                else
+                    delete grant.activeOrg;
+                await grant.save();
+            }
+            return grant;
+        },
         jwks: config.jwks,
         cookies: {
             keys: cookieKeys,
@@ -220,6 +250,29 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
             url: (_ctx, interaction) => `/auth/interaction/${interaction.uid}`,
         },
     });
+    // ── Modelo Grant estendido: persiste a org ativa ─────────────────────────────
+    // O oidc-provider v9 NÃO expõe uma opção `models` no config (confirmado no fonte
+    // instalado: `provider.js` instancia os modelos por `models.getGrant(this)` e
+    // `helpers/defaults.js` não tem chave alguma `models`), e o `Grant` filtra o
+    // payload por `IN_PAYLOAD` (`lib/models/grant.js` + `base_model.js`), então
+    // qualquer prop de topo fora da lista é DESCARTADA no `save()`/`find()`.
+    // Estendemos `IN_PAYLOAD` com `activeOrg` e injetamos a subclasse na INSTÂNCIA
+    // do provider via `Object.defineProperty`, que sombreia o getter `Grant` do
+    // protótipo. O `name` é fixado em `'Grant'` para que o nome do ADAPTER e o
+    // `kind` persistido continuem sendo os MESMOS registros (`BaseModel` usa
+    // `constructor.name` para ambos) — sem isso, grants novos/antigos divergiriam.
+    const BaseGrant = provider.Grant;
+    const GrantWithOrg = class GrantWithOrg extends BaseGrant {
+        static get IN_PAYLOAD() {
+            return [...BaseGrant.IN_PAYLOAD, 'activeOrg'];
+        }
+    };
+    Object.defineProperty(GrantWithOrg, 'name', { value: 'Grant', configurable: true });
+    Object.defineProperty(provider, 'Grant', {
+        value: GrantWithOrg,
+        writable: true,
+        configurable: true,
+    });
     provider.proxy = true;
     return provider;
 }

package/build/src/provider/interaction_actions.js

@@ -1,3 +1,4 @@
+import { readActiveOrgFromHostCtx } from '../host/active_org_cookie.js';
 import { InteractionSessionLostException, isInteractionSessionLost, } from '../host/interaction_recovery.js';
 /**
  * Choke point ÚNICO de `interactionDetails`: converte o `SessionNotFound` do
@@ -51,9 +52,15 @@ export function createInteractionActions(provider, deps) {
         },
         async consent(ctx) {
             const details = await interactionDetailsOrRecover(provider, ctx);
+            // O consent roda numa request do BROWSER, então a org ativa (cookie) está
+            // disponível AQUI — ao contrário do mint do id_token no /token, que é
+            // server-a-servidor e não carrega os cookies do usuário. Persistimos a org
+            // no Grant para que o fluxo authorization code volte a emitir org_*.
+            const activeOrg = readActiveOrgFromHostCtx(ctx);
             const grant = new provider.Grant({
                 accountId: details.session.accountId,
                 clientId: details.params.client_id,
+                ...(activeOrg ? { activeOrg } : {}),
             });
             grant.addOIDCScope(String(details.params.scope ?? 'openid'));
             // Resource Indicators (RFC 8707): quando o authorize/token pede um `resource`

package/build/src/provider/oidc_service.js

@@ -2,7 +2,7 @@ import { timingSafeEqual } from 'node:crypto';
 import { NoopRecorder } from '@adonis-agora/authkit-core';
 import Koa from 'koa';
 import mount from 'koa-mount';
-import { readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
+import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
 import { isFirstPartyClient } from '../host/branding.js';
 import { listKeyInfos, signingKeyAgeDays } from '../keys/keystore.js';
 import { wireProviderEvents } from '../observability/wire_provider_events.js';
@@ -82,8 +82,13 @@ export class OidcService {
                 const user = await config.findAccount(sub);
                 if (!user)
                     return undefined;
-                // Lê a org ativa do cookie de sessão (se organizations estiver disponível).
-                const activeOrg = readActiveOrgFromKoaCtx(ctx);
+                // Fonte PRIMÁRIA: a org persistida no Grant no consent (request do
+                // browser). No fluxo authorization code o id_token é mintado no /token
+                // — server-a-servidor, SEM cookies — então o cookie abaixo não existe
+                // ali. O cookie continua como FALLBACK para fluxos em que o id_token
+                // sai no próprio authorize (implicit/hybrid), onde a request é do browser.
+                const activeOrg = normalizeActiveOrg(ctx?.oidc?.entities?.Grant?.activeOrg) ??
+                    readActiveOrgFromKoaCtx(ctx);
                 // GATE de least-privilege: roles globais e claims de org só são emitidas
                 // para clients FIRST-PARTY. Capturamos o clientId aqui (fora do closure
                 // `claims()`, pois o `ctx` da request vive neste escopo).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.67.0",
+  "version": "0.68.1",
   "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",