@adonis-agora/authkit-server 0.81.3 → 0.82.1

package/README.md

@@ -120,7 +120,7 @@ router.post('/auth/interaction/:uid/consent', [AuthInteractionController, 'conse
 
 Escolha o backend no `config/authkit.ts`:
 - `adapters.redis({ connection })` — requer `@adonisjs/redis` configurado.
-- `adapters.database({ connection? })` — Lucid; rode a migração `authkit_oidc_payloads`.
+- `adapters.database({ connection? })` — Lucid; tabela `authkit_oidc_payloads`, criada pelo `ensureAuthkitSchema` no boot (com `schema: { autoManage: false }`, chame-o numa migração). A coluna indexada `account_id` mantém as buscas e revogações por conta em SQL; linhas antigas com `account_id` NULL continuam sendo encontradas. Postgres, MySQL e SQLite.
 
 ## Observabilidade
 

package/build/database/migrations/make_authkit_oidc_table.js

@@ -11,6 +11,9 @@ export default class extends BaseSchema {
             table.string('uid', 255).nullable().index();
             table.timestamp('expires_at', { useTz: true }).nullable();
             table.primary(['model_name', 'id']);
+            table.string('account_id', 255).nullable();
+            table.index(['model_name', 'account_id'], 'authkit_oidc_payloads_account_idx');
+            table.index(['expires_at'], 'authkit_oidc_payloads_expires_idx');
         });
     }
     async down() {

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

@@ -79,9 +79,17 @@ export function buildOrganizations(ctx) {
         },
         async listOrgsForAccount(accountId) {
             const memberships = await 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))
+                orgs.set(String(org.id), org);
             const result = [];
             for (const m of memberships) {
-                const org = await OrgModel.find(m.organizationId);
+                const org = orgs.get(String(m.organizationId));
                 if (org)
                     result.push({ ...toOrgSummary(org), role: m.role });
             }

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

@@ -36,4 +36,16 @@ export interface OidcAdapter {
      * (`new AdapterClass(model)`), então não recebe parâmetro.
      */
     list?(): Promise<EnumeratedArtifact[]>;
+    /**
+     * Artefatos vivos deste model cujo `payload.accountId` é `accountId` — o mesmo
+     * resultado de `list()` filtrado pela conta, sem enumerar as outras contas.
+     * OPCIONAL: ausente, os consumidores caem em `list()` + filtro. Tem de ser completo
+     * (a revogação confia nele): um artefato que fique de fora continua valendo.
+     */
+    listByAccount?(accountId: string): Promise<EnumeratedArtifact[]>;
+    /**
+     * Artefatos vivos deste model cujo `payload.grantId` está em `grantIds` — o
+     * mesmo resultado de `list()` filtrado pelos grants. OPCIONAL, como `listByAccount`.
+     */
+    listByGrantIds?(grantIds: string[]): Promise<EnumeratedArtifact[]>;
 }

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

@@ -19,4 +19,14 @@ export declare class DatabaseAdapter implements OidcAdapter {
      * console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens.
      */
     list(): Promise<EnumeratedArtifact[]>;
+    /**
+     * Artefatos vivos da conta, pelo índice `(model_name, account_id)`. As linhas com
+     * `account_id` NULL (gravadas antes da coluna existir, ou por uma versão anterior
+     * da lib durante um deploy) entram na leitura; o filtro final é sempre o
+     * `payload.accountId`, e as NULL que têm conta no payload são classificadas aqui,
+     * para não serem relidas na próxima busca.
+     */
+    listByAccount(accountId: string): Promise<EnumeratedArtifact[]>;
+    /** Artefatos vivos que referenciam algum dos grants, pela coluna indexada `grant_id`. */
+    listByGrantIds(grantIds: string[]): Promise<EnumeratedArtifact[]>;
 }

package/build/src/adapters/database_adapter.js

@@ -1,4 +1,31 @@
 const TABLE = 'authkit_oidc_payloads';
+/** Intervalo mínimo, por conexão, entre duas limpezas das linhas expiradas. */
+const PRUNE_INTERVAL_MS = 10 * 60_000;
+/** Quanto tempo a ausência da coluna `account_id` vale antes de re-checar. */
+const ACCOUNT_COLUMN_RECHECK_MS = 60_000;
+/** Tamanho máximo de uma lista `IN (...)`. */
+const IN_CHUNK = 500;
+const connectionStates = new WeakMap();
+function connectionState(db) {
+    let state = connectionStates.get(db);
+    if (!state) {
+        state = { accountColumn: null, accountColumnRecheckAt: 0, nextPruneAt: 0 };
+        connectionStates.set(db, state);
+    }
+    return state;
+}
+/** Dialetos que gravam `expires_at` como texto ISO-8601 (comparado lexicograficamente). */
+const TEXT_TIMESTAMP_DIALECTS = new Set([
+    'sqlite3',
+    'better-sqlite3',
+    'libsql',
+]);
+function chunks(items) {
+    const out = [];
+    for (let i = 0; i < items.length; i += IN_CHUNK)
+        out.push(items.slice(i, i + IN_CHUNK));
+    return out;
+}
 export class DatabaseAdapter {
     name;
     db;
@@ -9,10 +36,74 @@ export class DatabaseAdapter {
     #query() {
         return this.db.query().from(TABLE).where('model_name', this.name);
     }
+    /**
+     * Valor de `expires_at` (gravação e comparação) para o dialeto da conexão. No
+     * SQLite a coluna guarda texto ISO-8601 (o driver gravaria um `Date` como número,
+     * que não se compara com o texto já gravado); nos demais vai um `Date`, que o
+     * driver serializa no formato do banco — o MySQL recusa o ISO com `Z`.
+     */
+    #timestamp(ms) {
+        const state = connectionState(this.db);
+        if (state.dialect === undefined) {
+            // O factory passa o manager (`Database`) ou um `QueryClient` de conexão nomeada.
+            const db = this.db;
+            const client = typeof db.connection === 'function' ? db.connection() : db;
+            state.dialect = client?.dialect?.name ?? null;
+        }
+        const dialect = state.dialect;
+        return !dialect || TEXT_TIMESTAMP_DIALECTS.has(dialect)
+            ? new Date(ms).toISOString()
+            : new Date(ms);
+    }
+    /** `#query()` restrito às linhas não expiradas. */
+    #liveQuery() {
+        const now = this.#timestamp(Date.now());
+        return this.#query().where((q) => q.whereNull('expires_at').orWhere('expires_at', '>', now));
+    }
+    /**
+     * A coluna `account_id` existe? Probe por SELECT (searchPath-aware, como o
+     * `ensureAuthkitSchema`). "Presente" vale pela vida do processo; "ausente" é
+     * re-checado, para pegar o ALTER do boot que rodou depois do primeiro request.
+     */
+    async #hasAccountColumn() {
+        const state = connectionState(this.db);
+        if (state.accountColumn === true)
+            return true;
+        if (state.accountColumn === false && state.accountColumnRecheckAt > Date.now())
+            return false;
+        try {
+            await this.db.query().from(TABLE).select('account_id').limit(1);
+            state.accountColumn = true;
+        }
+        catch {
+            state.accountColumn = false;
+            state.accountColumnRecheckAt = Date.now() + ACCOUNT_COLUMN_RECHECK_MS;
+        }
+        return state.accountColumn;
+    }
+    /**
+     * Apaga as linhas expiradas de todos os models (no máximo uma vez por
+     * {@link PRUNE_INTERVAL_MS} por conexão). Linha expirada já é invisível para
+     * `find`/`list`; a limpeza só impede a tabela de crescer sem limite. Roda fora
+     * do caminho do request e nunca lança.
+     */
+    #maybePrune() {
+        const state = connectionState(this.db);
+        const now = Date.now();
+        if (state.nextPruneAt > now)
+            return;
+        state.nextPruneAt = now + PRUNE_INTERVAL_MS;
+        Promise.resolve()
+            .then(() => this.db
+            .query()
+            .from(TABLE)
+            .whereNotNull('expires_at')
+            .where('expires_at', '<=', this.#timestamp(now))
+            .delete())
+            .catch(() => { });
+    }
     async upsert(id, payload, expiresIn) {
-        // Armazenamos como ISO string para que o parse de expiração seja determinístico
-        // independente do backend (SQLite/Postgres) e do formato nativo de timestamp.
-        const expiresAt = expiresIn ? new Date(Date.now() + expiresIn * 1000).toISOString() : null;
+        const expiresAt = expiresIn ? this.#timestamp(Date.now() + expiresIn * 1000) : null;
         const row = {
             id,
             model_name: this.name,
@@ -22,13 +113,21 @@ export class DatabaseAdapter {
             uid: payload.uid ?? null,
             expires_at: expiresAt,
         };
-        const existing = await this.#query().where('id', id).first();
+        if (await this.#hasAccountColumn()) {
+            // NULL = "sem conta conhecida": as buscas por conta também leem essas linhas
+            // (e as classificam), então uma linha escrita sem a coluna nunca fica de fora.
+            const accountId = payload.accountId;
+            row.account_id = typeof accountId === 'string' && accountId ? accountId : null;
+        }
+        // Only whether the row exists matters: don't read the (possibly large) payload back.
+        const existing = await this.#query().where('id', id).select('id').first();
         if (existing) {
             await this.#query().where('id', id).update(row);
         }
         else {
             await this.db.table(TABLE).insert(row);
         }
+        this.#maybePrune();
     }
     async #parse(record) {
         if (!record)
@@ -53,10 +152,10 @@ export class DatabaseAdapter {
         const changed = await this.#query()
             .where('id', id)
             .where('payload', row.payload)
-            .where('expires_at', '>', new Date(now).toISOString())
+            .where('expires_at', '>', this.#timestamp(now))
             .update({
             payload: JSON.stringify({ ...payload, exp: Math.floor(now / 1000) + expiresIn }),
-            expires_at: new Date(now + expiresIn * 1000).toISOString(),
+            expires_at: this.#timestamp(now + expiresIn * 1000),
         });
         if (Number(changed) > 0)
             return true;
@@ -94,14 +193,81 @@ export class DatabaseAdapter {
      * console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens.
      */
     async list() {
-        const rows = await this.#query().orderBy('id', 'asc');
+        return this.#toArtifacts(await this.#liveQuery().orderBy('id', 'asc'));
+    }
+    /**
+     * Artefatos vivos da conta, pelo índice `(model_name, account_id)`. As linhas com
+     * `account_id` NULL (gravadas antes da coluna existir, ou por uma versão anterior
+     * da lib durante um deploy) entram na leitura; o filtro final é sempre o
+     * `payload.accountId`, e as NULL que têm conta no payload são classificadas aqui,
+     * para não serem relidas na próxima busca.
+     */
+    async listByAccount(accountId) {
+        if (!(await this.#hasAccountColumn())) {
+            return (await this.list()).filter((r) => r.payload.accountId === accountId);
+        }
+        const rows = await this.#liveQuery()
+            .where((q) => q.where('account_id', accountId).orWhereNull('account_id'))
+            .orderBy('id', 'asc');
+        const unclassified = new Map();
+        const result = [];
+        for (const artifact of this.#parseRows(rows)) {
+            const owner = artifact.payload.accountId;
+            if (artifact.unclassified && typeof owner === 'string' && owner) {
+                const ids = unclassified.get(owner) ?? [];
+                ids.push(artifact.id);
+                unclassified.set(owner, ids);
+            }
+            if (owner === accountId)
+                result.push({ id: artifact.id, payload: artifact.payload });
+        }
+        await this.#classify(unclassified);
+        return result;
+    }
+    /** Artefatos vivos que referenciam algum dos grants, pela coluna indexada `grant_id`. */
+    async listByGrantIds(grantIds) {
+        const wanted = new Set(grantIds);
+        const result = [];
+        for (const chunk of chunks([...wanted])) {
+            const rows = await this.#liveQuery().whereIn('grant_id', chunk).orderBy('id', 'asc');
+            for (const artifact of this.#toArtifacts(rows)) {
+                if (wanted.has(artifact.payload.grantId))
+                    result.push(artifact);
+            }
+        }
+        return result;
+    }
+    async #classify(byAccount) {
+        for (const [accountId, ids] of byAccount) {
+            for (const chunk of chunks(ids)) {
+                try {
+                    await this.#query()
+                        .whereNull('account_id')
+                        .whereIn('id', chunk)
+                        .update({ account_id: accountId });
+                }
+                catch {
+                    // Classificar é só otimização: a linha segue NULL e é lida de novo.
+                }
+            }
+        }
+    }
+    /** Linhas → artefatos, descartando as expiradas; `unclassified` = `account_id` NULL. */
+    #parseRows(rows) {
         const now = Date.now();
         const result = [];
         for (const row of rows) {
             if (row.expires_at && new Date(row.expires_at).getTime() <= now)
                 continue;
-            result.push({ id: row.id, payload: JSON.parse(row.payload) });
+            result.push({
+                id: row.id,
+                payload: JSON.parse(row.payload),
+                unclassified: row.account_id == null,
+            });
         }
         return result;
     }
+    #toArtifacts(rows) {
+        return this.#parseRows(rows).map(({ id, payload }) => ({ id, payload }));
+    }
 }

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

@@ -19,7 +19,7 @@ export declare class RedisAdapter implements OidcAdapter {
      * prefixo de chave do model (`<prefix>:<name>:*`). É limpo porque cada artefato
      * é uma chave única já namespaceada por `prefix` + `name`; SCAN é não-bloqueante
      * (cursor) ao contrário de KEYS. Usado pelo console admin (`Client`, `Session`,
-     * `Grant`, tokens).
+     * `Grant`, tokens). Cada página do SCAN é lida num único MGET.
      */
     list(): Promise<EnumeratedArtifact[]>;
 }

package/build/src/adapters/redis_adapter.js

@@ -101,15 +101,23 @@ export class RedisAdapter {
         return this.find(id);
     }
     async consume(id) {
-        const found = await this.find(id);
-        if (!found)
+        const key = this.#key(id);
+        // GET + TTL in one round trip (a pipeline, read-only: nothing changes before the SET).
+        const results = await this.redis.pipeline().get(key).ttl(key).exec();
+        const [getError, data] = results?.[0] ?? [null, null];
+        if (getError)
+            throw getError;
+        if (!data)
             return;
+        const [ttlError, ttl] = results?.[1] ?? [null, -1];
+        if (ttlError)
+            throw ttlError;
+        const found = JSON.parse(data);
         found.consumed = Math.floor(Date.now() / 1000);
-        const ttl = await this.redis.ttl(this.#key(id));
         if (ttl > 0)
-            await this.redis.set(this.#key(id), JSON.stringify(found), 'EX', ttl);
+            await this.redis.set(key, JSON.stringify(found), 'EX', ttl);
         else
-            await this.redis.set(this.#key(id), JSON.stringify(found));
+            await this.redis.set(key, JSON.stringify(found));
     }
     async destroy(id) {
         await this.redis.del(this.#key(id));
@@ -128,24 +136,27 @@ export class RedisAdapter {
      * prefixo de chave do model (`<prefix>:<name>:*`). É limpo porque cada artefato
      * é uma chave única já namespaceada por `prefix` + `name`; SCAN é não-bloqueante
      * (cursor) ao contrário de KEYS. Usado pelo console admin (`Client`, `Session`,
-     * `Grant`, tokens).
+     * `Grant`, tokens). Cada página do SCAN é lida num único MGET.
      */
     async list() {
         const prefix = `${this.prefix}:${this.name}:`;
         const result = [];
         let cursor = '0';
         do {
-            const [next, keys] = await this.redis.scan(cursor, 'MATCH', `${prefix}*`, 'COUNT', 100);
+            const [next, keys] = await this.redis.scan(cursor, 'MATCH', `${prefix}*`, 'COUNT', 1000);
             cursor = next;
-            for (const key of keys) {
-                const data = await this.redis.get(key);
+            if (keys.length === 0)
+                continue;
+            const values = await this.redis.mget(...keys);
+            keys.forEach((key, i) => {
+                const data = values[i];
                 if (!data)
-                    continue;
+                    return;
                 result.push({
                     id: key.slice(prefix.length),
                     payload: JSON.parse(data),
                 });
-            }
+            });
         } while (cursor !== '0');
         result.sort((a, b) => a.id.localeCompare(b.id));
         return result;

package/build/src/host/admin_sessions_service.js

@@ -122,6 +122,32 @@ export class AdminSessionsService {
             return [];
         return adapter.list();
     }
+    /** Artefatos do model da conta — pela busca por conta do adapter, quando existe. */
+    async #listModelOfAccount(model, accountId) {
+        const adapter = this.#adapter(model);
+        if (adapter.listByAccount)
+            return adapter.listByAccount(accountId);
+        if (!adapter.list)
+            return [];
+        return (await adapter.list()).filter((r) => r.payload.accountId === accountId);
+    }
+    /** Artefatos de um model token que referenciam algum dos grants. */
+    async #listTokensOfGrants(model, grantIds) {
+        if (grantIds.size === 0)
+            return [];
+        const adapter = this.#adapter(model);
+        if (adapter.listByGrantIds)
+            return adapter.listByGrantIds([...grantIds]);
+        if (!adapter.list)
+            return [];
+        return (await adapter.list()).filter((r) => grantIds.has(r.payload.grantId));
+    }
+    /** Grants da conta, exceto os espelhos `pgrant_` de Account Tokens do Poppy. */
+    async #accountGrants(accountId) {
+        // Os grants `pgrant_` são o espelho de um Account Token do Poppy (Bearer de MCP) — aparecem e
+        // são revogados como personal agent, não como app OIDC.
+        return (await this.#listModelOfAccount('Grant', accountId)).filter((r) => !r.id.startsWith('pgrant_'));
+    }
     /**
      * Conta TODAS as sessões ativas do IdP (todas as contas). 0 quando o adapter não
      * enumera. Usado pelo dashboard de métricas.
@@ -132,10 +158,8 @@ export class AdminSessionsService {
     }
     /** Lista as sessões ativas da conta (vazio quando o adapter não enumera). */
     async listSessions(accountId) {
-        const rows = await this.#listModel('Session');
-        return rows
-            .filter((r) => r.payload.accountId === accountId)
-            .map((r) => ({
+        const rows = await this.#listModelOfAccount('Session', accountId);
+        return rows.map((r) => ({
             id: r.id,
             accountId,
             loginTs: r.payload.loginTs,
@@ -183,14 +207,12 @@ export class AdminSessionsService {
      * enumeração de cada model token), feitas só quando o adapter enumera.
      */
     async listGrants(accountId) {
-        const rows = await this.#listModel('Grant');
-        // Os grants `pgrant_` são o espelho de um Account Token do Poppy (Bearer de MCP) — aparecem e
-        // são revogados como personal agent, não como app OIDC.
-        const grants = rows.filter((r) => r.payload.accountId === accountId && !r.id.startsWith('pgrant_'));
+        const grants = await this.#accountGrants(accountId);
         if (grants.length === 0)
             return [];
-        const atByGrant = await this.#countByGrant('AccessToken');
-        const rtByGrant = await this.#countByGrant('RefreshToken');
+        const grantIds = new Set(grants.map((g) => g.id));
+        const atByGrant = await this.#countByGrant('AccessToken', grantIds);
+        const rtByGrant = await this.#countByGrant('RefreshToken', grantIds);
         return grants.map((g) => ({
             id: g.id,
             accountId,
@@ -199,9 +221,9 @@ export class AdminSessionsService {
             refreshTokens: rtByGrant.get(g.id) ?? 0,
         }));
     }
-    /** Conta artefatos de um model token agrupados por `grantId`. */
-    async #countByGrant(model) {
-        const rows = await this.#listModel(model);
+    /** Conta os artefatos de um model token dos grants, agrupados por `grantId`. */
+    async #countByGrant(model, grantIds) {
+        const rows = await this.#listTokensOfGrants(model, grantIds);
         const map = new Map();
         for (const r of rows) {
             const gid = r.payload.grantId;
@@ -231,7 +253,7 @@ export class AdminSessionsService {
         // Revogamos todos os grants da conta (que pertencem à conta, não à sessão
         // específica). A sessão corrente gerará novos grants no próximo authorize.
         // Isso garante que sessões antigas não mantenham tokens vivos.
-        const grants = await this.listGrants(accountId);
+        const grants = await this.#accountGrants(accountId);
         const grantIds = new Set(grants.map((g) => g.id));
         let accessTokens = 0;
         let refreshTokens = 0;
@@ -279,7 +301,7 @@ export class AdminSessionsService {
         for (const s of sessions) {
             await sessionAdapter.destroy(s.id);
         }
-        const grants = await this.listGrants(accountId);
+        const grants = await this.#accountGrants(accountId);
         const grantIds = new Set(grants.map((g) => g.id));
         let accessTokens = 0;
         let refreshTokens = 0;
@@ -314,7 +336,7 @@ export class AdminSessionsService {
      */
     async revokeClientGrants(accountId, clientId) {
         const grantAdapter = this.#adapter('Grant');
-        const grants = (await this.listGrants(accountId)).filter((g) => g.clientId === clientId);
+        const grants = (await this.#accountGrants(accountId)).filter((g) => g.payload.clientId === clientId);
         const grantIds = new Set(grants.map((g) => g.id));
         const accessTokens = await this.#destroyTokensOfGrants('AccessToken', grantIds);
         const refreshTokens = await this.#destroyTokensOfGrants('RefreshToken', grantIds);
@@ -346,12 +368,10 @@ export class AdminSessionsService {
      */
     async revokeOrgGrants(orgId, accountId) {
         const grantAdapter = this.#adapter('Grant');
-        const rows = await this.#listModel('Grant');
-        const grants = rows.filter((r) => {
-            if (normalizeActiveOrg(r.payload.activeOrg)?.orgId !== orgId)
-                return false;
-            return accountId === undefined || r.payload.accountId === accountId;
-        });
+        const rows = accountId === undefined
+            ? await this.#listModel('Grant')
+            : await this.#listModelOfAccount('Grant', accountId);
+        const grants = rows.filter((r) => normalizeActiveOrg(r.payload.activeOrg)?.orgId === orgId);
         if (grants.length === 0) {
             return { sessions: 0, grants: 0, accessTokens: 0, refreshTokens: 0 };
         }
@@ -375,17 +395,9 @@ export class AdminSessionsService {
     /** Destrói (quando enumerável) os artefatos de um model token cujos grantId estão em `grantIds`. */
     async #destroyTokensOfGrants(model, grantIds) {
         const adapter = this.#adapter(model);
-        if (!adapter.list)
-            return 0;
-        const rows = await adapter.list();
-        let count = 0;
-        for (const r of rows) {
-            const gid = r.payload.grantId;
-            if (gid && grantIds.has(gid)) {
-                await adapter.destroy(r.id);
-                count++;
-            }
-        }
-        return count;
+        const rows = await this.#listTokensOfGrants(model, grantIds);
+        for (const r of rows)
+            await adapter.destroy(r.id);
+        return rows.length;
     }
 }

package/build/src/host/persistent_rp_session.js

@@ -1,6 +1,25 @@
 import { ACCOUNT_IDP_SESSION_KEY, readIdpSession } from './idp_session_bridge.js';
 import { impersonationState } from './impersonation_session.js';
 import { assertAccountEnabled } from './login_attempt.js';
+/**
+ * How long (seconds) a renewal stays good enough: a linked RP whose IdP session was
+ * renewed less than this ago, with the current TTL, is not renewed again. Without
+ * it every authenticated request wrote the IdP session row and re-sent its cookie.
+ */
+const RENEW_RESOLUTION_SEC = 60;
+/**
+ * The linked RP's IdP session already expires between `ttl - RENEW_RESOLUTION_SEC`
+ * and `ttl` from now, i.e. it was renewed with this TTL moments ago. Renewing again
+ * would only move the expiry by those few seconds. A session that expires LATER
+ * than `now + ttl` (the TTL was lowered) is still renewed, which shortens it.
+ * Restoration (no local login yet) always renews.
+ */
+function renewedRecently(idp, ttl, current, linkedUid) {
+    if (!current || linkedUid !== idp.uid || typeof idp.exp !== 'number')
+        return false;
+    const remaining = idp.exp - Date.now() / 1000;
+    return remaining <= ttl && remaining > ttl - RENEW_RESOLUTION_SEC;
+}
 /** Same-host RP restoration: the signed IdP cookie is the persistent credential. */
 export async function ensureRpSession(ctx, sessionKey) {
     const service = await ctx.containerResolver.make('authkit.server');
@@ -39,7 +58,7 @@ export async function ensureRpSession(ctx, sessionKey) {
     }
     const adapter = service.provider.Session.adapter;
     const ttl = service.sessionTtlHolder.rememberSec;
-    if (adapter.renewSession) {
+    if (adapter.renewSession && !renewedRecently(idp, ttl, current, linkedUid)) {
         if (!(await adapter.renewSession(idp.id, ttl))) {
             if (linkedUid)
                 ctx.session.clear();

package/build/src/host/runtime_settings.d.ts

@@ -108,10 +108,9 @@ export declare class RuntimeSettings implements SettingsCapability {
     private readonly db;
     private readonly ttlMs;
     private readonly connectionName;
-    private cache;
-    /** null = não foi verificado ainda; false = tabela ausente; true = presente */
-    private tablePresent;
+    private readonly shared;
     constructor(db: any, opts?: RuntimeSettingsOptions);
+    private get cache();
     /**
      * Retorna o objeto de conexão Lucid correto.
      * Quando `connectionName` está definido, usa `db.connection(name)`;
@@ -128,6 +127,9 @@ export declare class RuntimeSettings implements SettingsCapability {
      * detecta a tabela corretamente independente do schema.
      *
      * Fail-safe: qualquer erro → false (tabela considerada ausente, sem lançar).
+     * "Presente" vale pela vida do processo; "ausente" é re-verificado após o TTL,
+     * para que uma migração rodada com o app no ar (ou um erro transitório) não
+     * desligue as settings até o restart.
      */
     private hasTable;
     getSetting(key: string, orgId?: string | null): Promise<unknown | null>;

package/build/src/host/runtime_settings.js

@@ -57,6 +57,24 @@ import { isSettingLocked, SettingLockedError } from './config_locks.js';
 export function supportsSettings(obj) {
     return !!obj && typeof obj.getSetting === 'function';
 }
+const sharedStates = new WeakMap();
+function sharedStateFor(db, connection) {
+    const fresh = () => ({ cache: new Map(), tablePresent: null, tableAbsentUntil: 0 });
+    if (!db || (typeof db !== 'object' && typeof db !== 'function'))
+        return fresh();
+    let byConnection = sharedStates.get(db);
+    if (!byConnection) {
+        byConnection = new Map();
+        sharedStates.set(db, byConnection);
+    }
+    const name = connection ?? '';
+    let state = byConnection.get(name);
+    if (!state) {
+        state = fresh();
+        byConnection.set(name, state);
+    }
+    return state;
+}
 /** Chave de cache: combina key + escopo de org (null = global). */
 function cacheKey(key, orgId) {
     return orgId ? `${key}\x00${orgId}` : key;
@@ -70,13 +88,15 @@ export class RuntimeSettings {
     db;
     ttlMs;
     connectionName;
-    cache = new Map();
-    /** null = não foi verificado ainda; false = tabela ausente; true = presente */
-    tablePresent = null;
+    shared;
     constructor(db, opts = {}) {
         this.db = db;
         this.ttlMs = opts.ttlMs ?? 15_000;
         this.connectionName = opts.connection;
+        this.shared = sharedStateFor(db, opts.connection);
+    }
+    get cache() {
+        return this.shared.cache;
     }
     /**
      * Retorna o objeto de conexão Lucid correto.
@@ -96,17 +116,24 @@ export class RuntimeSettings {
      * detecta a tabela corretamente independente do schema.
      *
      * Fail-safe: qualquer erro → false (tabela considerada ausente, sem lançar).
+     * "Presente" vale pela vida do processo; "ausente" é re-verificado após o TTL,
+     * para que uma migração rodada com o app no ar (ou um erro transitório) não
+     * desligue as settings até o restart.
      */
     async hasTable() {
-        if (this.tablePresent !== null)
-            return this.tablePresent;
+        const shared = this.shared;
+        if (shared.tablePresent === true)
+            return true;
+        if (shared.tablePresent === false && shared.tableAbsentUntil > Date.now())
+            return false;
         try {
             await this.conn().from('auth_settings').select('key').limit(1);
-            this.tablePresent = true;
+            shared.tablePresent = true;
             return true;
         }
         catch {
-            this.tablePresent = false;
+            shared.tablePresent = false;
+            shared.tableAbsentUntil = Date.now() + this.ttlMs;
             return false;
         }
     }