@oondemand/oon-core-back 0.7.16 → 0.7.19

package/README.md

@@ -57,6 +57,12 @@ O comando de delivery preserva `central.app.json` em dois pontos da imagem:
 
 Centrais legadas sem o manifesto continuam suportadas. O empacotador cria uma pasta intermediária vazia, evitando tornar `central.app.json` obrigatório para aplicações que ainda usam somente `central.config.js`.
 
+### `bin/delivery.js deploy` (legado)
+
+O subcomando `deploy` de `bin/delivery.js` é legado. Ele provisiona e aplica o runtime diretamente, mas não injeta capabilities no runtime. Não o use em publicações novas; os subcomandos `context` e `state` continuam disponíveis.
+
+Na falha de inicialização da imagem, o runtime registra as issues do manifesto, uma por linha, no formato ` - <path>: <mensagem>`, antes da linha `OON_STARTUP_FAILURE`. As mensagens passam pela mesma sanitização do CLI e o stack não é impresso.
+
 ## Rótulos de campos relacionados
 
 Por padrão, campos declarados com `fields.ref(...)` continuam sendo devolvidos pelo CRUD como `ObjectId`. Uma model pode optar pela população segura das referências usadas em grids e cards:

package/bin/cli.js

@@ -134,4 +134,11 @@ Códigos de saída: ${Object.entries(EXIT_CODES).map(([key, value]) => `${value}
   }
 }
 
-main().catch((err) => { console.error(sanitizeMessage(err?.message || err)); process.exit(1); });
+main().catch((err) => {
+  console.error(sanitizeMessage(err?.message || err));
+  // Manifest errors (e.g. AppManifestError) carry the actionable detail in issues.
+  if (Array.isArray(err?.issues)) {
+    for (const issue of err.issues) console.error(` - ${issue?.path || "$"}: ${sanitizeMessage(issue?.message)}`);
+  }
+  process.exit(1);
+});

package/bin/delivery.js

@@ -37,6 +37,7 @@ async function main() {
     });
     return;
   }
+  // Legado: "deploy" não injeta capabilities no runtime. Ver README.
   if (command === "deploy") {
     const contextFile = required(flag("--context"), "--context");
     const imageDigest = required(flag("--image-digest"), "--image-digest");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oondemand/oon-core-back",
-  "version": "0.7.16",
+  "version": "0.7.19",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oondemand/oon-platform.git",

package/src/api/access.routes.js

@@ -103,6 +103,12 @@ router.get("/role-catalog", (_req, res) => {
   res.json(publicRoleCatalog());
 });
 
+// F5.2: métricas de uso declaradas no central.app.json.
+router.get("/usage-metrics", (_req, res) => {
+  res.set("Cache-Control", "public, max-age=300");
+  res.json(require("../manifest/usageMetrics").publicUsageMetrics(require("../core/context").config));
+});
+
 router.get("/rbac", (_req, res) => {
   res.json(publicPolicy());
 });

package/src/api/activation.routes.js

@@ -25,29 +25,12 @@ const {
   event,
 } = require("../core/utils/instanceActivation");
 const { getAppCode, getBaseUrl } = require("../core/utils/activationProvider");
+const { createActivationRateLimit } = require("./activationRateLimit");
 
 const router = express.Router();
-const attempts = new Map();
 const DEV_LOCAL_PATH = "/integracao/dev-local/ativar-central";
 
-function rateLimit(req, res, next) {
-  const key = req.ip || "local";
-  const now = Date.now();
-  const list = (attempts.get(key) || []).filter((time) => now - time < 60000);
-
-  if (list.length >= 30) {
-    return res.status(429).json({
-      error: {
-        code: "RATE_LIMIT",
-        message: "Muitas tentativas de ativação.",
-      },
-    });
-  }
-
-  list.push(now);
-  attempts.set(key, list);
-  next();
-}
+const rateLimit = createActivationRateLimit();
 
 function assertMember() {
   if (role() === "root") {

package/src/api/activationRateLimit.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const mongoose = require("../core/database/mongoose");
+
+/**
+ * Limite de tentativas nas rotas de ativação: `limit` requisições por IP a
+ * cada janela fixa de `windowMs`.
+ *
+ * O contador fica no MongoDB para valer para o App inteiro: com o contador em
+ * memória, cada réplica tinha o seu e o limite real virava `limit × réplicas`.
+ * Sem conexão com o banco (boot, queda), usa o contador em memória do processo
+ * para não bloquear a ativação.
+ */
+const COLLECTION = "oon_activation_attempts";
+
+function createActivationRateLimit({
+  limit = 30,
+  windowMs = 60000,
+  now = () => Date.now(),
+  connection = () => mongoose.connection,
+} = {}) {
+  const memory = new Map();
+  let indexReady = null;
+
+  function memoryCount(key, windowStart) {
+    const current = memory.get(key);
+    const next = current && current.windowStart === windowStart ? current.count + 1 : 1;
+    memory.set(key, { windowStart, count: next });
+    if (memory.size > 10000) {
+      for (const [entryKey, entry] of memory) if (entry.windowStart !== windowStart) memory.delete(entryKey);
+    }
+    return next;
+  }
+
+  async function sharedCount(db, key, windowStart) {
+    const collection = db.collection(COLLECTION);
+    if (!indexReady) {
+      indexReady = collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 }).catch((error) => {
+        indexReady = null;
+        throw error;
+      });
+    }
+    await indexReady;
+    const result = await collection.findOneAndUpdate(
+      { _id: `${key}:${windowStart}` },
+      { $inc: { count: 1 }, $setOnInsert: { expiresAt: new Date(windowStart + windowMs * 2) } },
+      { upsert: true, returnDocument: "after", maxTimeMS: 2000 },
+    );
+    const doc = result && Object.hasOwn(result, "value") ? result.value : result;
+    return Number(doc?.count || 1);
+  }
+
+  async function count(key) {
+    const windowStart = Math.floor(now() / windowMs) * windowMs;
+    const db = connection();
+    if (db?.readyState === 1) {
+      try {
+        return await sharedCount(db, key, windowStart);
+      } catch (error) {
+        console.warn(`[OonCore] Limite de ativação usando contador local: ${error?.message || error}`);
+      }
+    }
+    return memoryCount(key, windowStart);
+  }
+
+  return async function activationRateLimit(req, res, next) {
+    try {
+      const attempts = await count(req.ip || "local");
+      if (attempts > limit) {
+        return res.status(429).json({
+          error: {
+            code: "RATE_LIMIT",
+            message: "Muitas tentativas de ativação.",
+          },
+        });
+      }
+      return next();
+    } catch (error) {
+      return next(error);
+    }
+  };
+}
+
+module.exports = { createActivationRateLimit, COLLECTION };

package/src/boot/database.js

@@ -1,7 +1,7 @@
 const mongoose = require("../core/database/mongoose");
 const registry = require("../core/registry");
 const ctx = require("../core/context");
-const { DEFAULTS, poolOptions } = require("../core/database/policy");
+const { poolOptions, resolvePolicy } = require("../core/database/policy");
 const { attachPoolMetrics } = require("../core/database/metrics");
 
 function buildMongoUri() {
@@ -23,7 +23,7 @@ function buildMongoUri() {
 }
 
 function connectionOptions() {
-  const pool = poolOptions();
+  const pool = poolOptions(resolvePolicy().policy);
   if (process.env.MONGO_URI) return pool;
 
   const hasUser = Boolean(process.env.DB_USER);
@@ -49,24 +49,55 @@ function databaseLabel(uri) {
   }
 }
 
+/**
+ * Modo da sincronização de índices no boot (`OON_SYNC_INDEXES`):
+ * - `create` (padrão; também `true`): só cria os índices declarados que faltam
+ *   e informa os obsoletos sem removê-los. Seguro com várias réplicas subindo
+ *   juntas e durante o rolling update, quando a versão anterior ainda está no
+ *   ar e pode depender de um índice que a nova versão não declara mais.
+ * - `drop`: comportamento anterior (`syncIndexes`), que também remove os
+ *   obsoletos. Usar apenas de forma explícita, com uma única réplica no ar.
+ * - `false`: não sincroniza.
+ */
+function indexSyncMode() {
+  const value = String(process.env.OON_SYNC_INDEXES ?? "create").trim().toLowerCase();
+  if (value === "false") return "off";
+  if (value === "drop") return "drop";
+  return "create";
+}
+
 function shouldSyncDeclaredIndexes() {
-  return String(process.env.OON_SYNC_INDEXES ?? "true").toLowerCase() !== "false";
+  return indexSyncMode() !== "off";
 }
 
 async function syncDeclaredIndexes(entries = registry.listModels()) {
-  if (!shouldSyncDeclaredIndexes()) return [];
+  const mode = indexSyncMode();
+  if (mode === "off") return [];
 
   const results = [];
   for (const entry of entries) {
     const model = entry?.mongooseModel;
-    if (!model || typeof model.syncIndexes !== "function") continue;
-
-    const dropped = await model.syncIndexes();
-    const normalized = Array.isArray(dropped) ? dropped : [];
-    results.push({ model: entry.name, dropped: normalized });
+    if (!model) continue;
+
+    if (mode === "drop") {
+      if (typeof model.syncIndexes !== "function") continue;
+      const dropped = await model.syncIndexes();
+      const normalized = Array.isArray(dropped) ? dropped : [];
+      results.push({ model: entry.name, dropped: normalized, obsolete: [] });
+      if (normalized.length) {
+        console.log(`[OonCore] Índices obsoletos removidos de ${entry.name}: ${normalized.join(", ")}`);
+      }
+      continue;
+    }
 
-    if (normalized.length) {
-      console.log(`[OonCore] Índices obsoletos removidos de ${entry.name}: ${normalized.join(", ")}`);
+    if (typeof model.createIndexes !== "function") continue;
+    // createIndex é idempotente no MongoDB: réplicas simultâneas não conflitam.
+    await model.createIndexes();
+    const diff = typeof model.diffIndexes === "function" ? await model.diffIndexes() : null;
+    const obsolete = Array.isArray(diff?.toDrop) ? diff.toDrop : [];
+    results.push({ model: entry.name, dropped: [], obsolete });
+    if (obsolete.length) {
+      console.log(`[OonCore] Índices não declarados mantidos em ${entry.name}: ${obsolete.join(", ")} (remova com OON_SYNC_INDEXES=drop em uma janela com uma única réplica).`);
     }
   }
 
@@ -89,7 +120,8 @@ async function connectDB() {
     metrics?.dispose();
     throw error;
   }
-  console.log("[OonCore] database policy", JSON.stringify({ ...DEFAULTS, uncoveredModels: Object.values(mongoose.models).filter(model => !model.schema[Symbol.for("oon.database.policy.schema.v1")]).length }));
+  const { mode, policy } = resolvePolicy();
+  console.log("[OonCore] database policy", JSON.stringify({ performanceMode: mode, ...policy, uncoveredModels: Object.values(mongoose.models).filter(model => !model.schema[Symbol.for("oon.database.policy.schema.v1")]).length }));
   await syncDeclaredIndexes();
   console.log(`Conectado ao MongoDB (${databaseLabel(uri)})`);
   return mongoose.connection;
@@ -100,6 +132,7 @@ module.exports = {
   buildMongoUri,
   connectionOptions,
   databaseLabel,
+  indexSyncMode,
   shouldSyncDeclaredIndexes,
   syncDeclaredIndexes,
 };

package/src/boot/gracefulShutdown.js

@@ -0,0 +1,64 @@
+"use strict";
+
+/**
+ * Desligamento sem perda para o servidor HTTP do runtime.
+ *
+ * Em deploy, escala ou exclusão de slot o Kubernetes envia SIGTERM. Sem este
+ * tratamento o processo morria na hora, cortando requisições em andamento e
+ * tarefas em segundo plano. Aqui o servidor para de aceitar conexões, espera as
+ * requisições em andamento (até `timeoutMs`), executa as etapas de drenagem em
+ * ordem e só então encerra o processo.
+ */
+function installGracefulShutdown(server, {
+  drain = [],
+  timeoutMs = Number(process.env.OON_SHUTDOWN_TIMEOUT_MS) || 15000,
+  signals = ["SIGTERM", "SIGINT"],
+  processRef = process,
+  log = console,
+} = {}) {
+  let shutting = null;
+
+  const closeServer = () => new Promise((resolve) => {
+    if (!server.listening) return resolve();
+    server.close(() => resolve());
+    // Conexões keep-alive ociosas não podem segurar o fechamento.
+    server.closeIdleConnections?.();
+  });
+
+  const shutdown = (signal) => {
+    if (shutting) return shutting;
+    log.log(`[OonCore] ${signal} recebido; encerrando sem aceitar novas requisições.`);
+    let timer;
+    const deadline = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        log.warn(`[OonCore] Encerramento excedeu ${timeoutMs} ms; conexões restantes serão fechadas.`);
+        server.closeAllConnections?.();
+        resolve("timeout");
+      }, timeoutMs);
+      timer.unref?.();
+    });
+    const graceful = (async () => {
+      await closeServer();
+      for (const step of drain) {
+        try {
+          await step();
+        } catch (error) {
+          log.error(`[OonCore] Falha ao drenar durante o encerramento: ${error?.message || error}`);
+        }
+      }
+      return "drained";
+    })();
+    shutting = Promise.race([graceful, deadline]).then((outcome) => {
+      clearTimeout(timer);
+      log.log(`[OonCore] Encerramento concluído (${outcome}).`);
+      processRef.exit(0);
+      return outcome;
+    });
+    return shutting;
+  };
+
+  for (const signal of signals) processRef.once(signal, () => { void shutdown(signal); });
+  return { shutdown };
+}
+
+module.exports = { installGracefulShutdown };

package/src/boot/startServer.js

@@ -3,6 +3,10 @@ const { connectDB } = require("./database");
 const { createApp } = require("./createApp");
 const { loadCentral } = require("./loadCentral");
 const transactionalEmail = require("../capabilities/transactionalEmail");
+const { startTenantDataPurges, stopTenantDataPurges } = require("../core/runtime/tenantDataPurge");
+const mongoose = require("../core/database/mongoose");
+const { startProcessJobs, stopProcessJobs } = require("../manifest/processRuntime");
+const { installGracefulShutdown } = require("./gracefulShutdown");
 const {
   isLocalRuntime,
   validateLocalRuntime,
@@ -14,12 +18,19 @@ const {
  * banco, monta a app e escuta a porta. É o `start` da API pública e o
  * alvo do `oonCore-back start`.
  *
- * @param {{ cwd?: string, listen?: boolean }} opts
+ * Com `handleSignals` (padrão), SIGTERM/SIGINT encerram sem perda: o servidor
+ * para de aceitar conexões, espera as requisições em andamento, para o worker
+ * de e-mail e o da fila de recálculo (as tarefas pendentes ficam no banco
+ * para outra réplica) e fecha o banco antes de sair.
+ *
+ * @param {{ cwd?: string, listen?: boolean, handleSignals?: boolean }} opts
  */
-async function start({ cwd = process.cwd(), listen = true } = {}) {
+async function start({ cwd = process.cwd(), listen = true, handleSignals = true } = {}) {
   loadCentral(cwd);
   await connectDB();
   await transactionalEmail.initialize();
+  startTenantDataPurges();
+  await startProcessJobs();
   const host = isLocalRuntime() ? "127.0.0.1" : undefined;
   validateLocalRuntime({ host: host || process.env.HOST || "127.0.0.1" });
   const localSession = isLocalRuntime() ? await prepareLocalDevelopmentSession() : null;
@@ -39,8 +50,20 @@ async function start({ cwd = process.cwd(), listen = true } = {}) {
       }
       console.log(`${ctx.config.serviceName} rodando na porta ${port} e conectado ao MongoDB`);
       console.log("****************************************************************");
-      const stop = () => transactionalEmail.stopWorker();
+      const stop = () => { transactionalEmail.stopWorker(); void stopTenantDataPurges(); };
       server.once("close", stop);
+      if (handleSignals) {
+        installGracefulShutdown(server, {
+          drain: [
+            () => transactionalEmail.stopWorker(),
+            () => stopProcessJobs(),
+            () => stopTenantDataPurges(),
+            // F5.3: o consumo ainda em memória vira lote na outbox antes de sair.
+            () => require("../core/usage/reporter").stop(),
+            () => mongoose.disconnect(),
+          ],
+        });
+      }
       resolve({ app, server });
     });
   });

package/src/capabilities/transactionalEmail/models.js

@@ -17,6 +17,8 @@ function getModels() {
   DispatchSchema.index({ status: 1, nextRetryAt: 1, leaseExpiresAt: 1 });
   return { Config: model("OonTransactionalEmailConfig", ConfigSchema, "oon_transactional_email_configs"), Template: model("OonEmailTemplate", TemplateSchema, "oon_email_templates"), Dispatch: model("OonEmailDispatch", DispatchSchema, "oon_email_dispatches") };
 }
-async function syncIndexes() { const models = getModels(); return Promise.all(Object.values(models).map((entry) => entry.syncIndexes())); }
+// Só cria índices que faltam: várias réplicas sobem juntas e a versão anterior
+// ainda pode estar no ar durante o rolling update.
+async function syncIndexes() { const models = getModels(); return Promise.all(Object.values(models).map((entry) => entry.createIndexes())); }
 module.exports = { getModels, syncIndexes };
 

package/src/capabilities/transactionalEmail/worker.js

@@ -10,13 +10,19 @@ const { renderTemplate } = require("./templates");
 const state = { running: false, owner: `${process.pid}:${crypto.randomUUID()}`, lastProgressAt: null, timer: null };
 function backoff(attempt) { const base = Math.min(3600000, 1000 * (2 ** Math.max(0, attempt - 1))); return base + Math.floor(Math.random() * Math.max(250, base * 0.2)); }
 async function lease() { const { Dispatch } = getModels(); const now = new Date(); return Dispatch.findOneAndUpdate({ status: { $in: ["accepted", "failed", "processing"] }, nextRetryAt: { $lte: now }, $or: [{ leaseExpiresAt: { $exists: false } }, { leaseExpiresAt: null }, { leaseExpiresAt: { $lte: now } }] }, { $set: { status: "processing", leaseOwner: state.owner, leaseExpiresAt: new Date(Date.now() + 60000) }, $inc: { attempts: 1 } }, { new: true, sort: { nextRetryAt: 1, createdAt: 1 } }); }
+// Com várias réplicas, um envio que passe do prazo do lease pode ser assumido
+// por outra réplica. Antes de enviar e ao gravar o resultado, a réplica
+// confirma que ainda é a dona do lease; se não for, desiste sem sobrescrever.
+async function stillOwned(Dispatch, dispatch) { return Boolean(await Dispatch.exists({ _id: dispatch._id, leaseOwner: state.owner, leaseExpiresAt: { $gt: new Date() } })); }
+async function saveIfOwned(Dispatch, dispatch) { const result = await Dispatch.updateOne({ _id: dispatch._id, leaseOwner: state.owner }, dispatch.getChanges()); return Number(result?.matchedCount ?? result?.n ?? 0) > 0; }
 async function processOne() {
   const dispatch = await lease(); if (!dispatch) return false;
-  const { Template } = getModels();
+  const { Template, Dispatch } = getModels();
   try {
     const config = await configuration({ appCode: dispatch.scopeKey.split(":")[1], tenantId: dispatch.scopeKey.includes(":tenant:") ? dispatch.scopeKey.split(":tenant:")[1] : undefined });
     const template = await Template.findOne({ scopeKey: dispatch.scopeKey, code: dispatch.templateCode, version: dispatch.templateVersion }).lean();
     const payload = secrets.decrypt(dispatch.protectedPayload); const rendered = renderTemplate(template, payload.variables); const apiKey = secrets.decrypt(config.encryptedEnvelope);
+    if (!await stillOwned(Dispatch, dispatch)) { console.warn(JSON.stringify({ event: "transactionalEmail.worker.lease_lost", stage: "before_send" })); return true; }
     const result = await providers.sendgrid.send({ to: payload.to, from: { email: config.senderEmail, name: config.senderName }, replyTo: config.replyTo, ...rendered }, apiKey);
     dispatch.status = "provider_accepted"; dispatch.providerMessageId = result.providerMessageId; dispatch.sentAt = new Date(); dispatch.leaseOwner = undefined; dispatch.leaseExpiresAt = undefined; dispatch.lastError = undefined;
   } catch (error) {
@@ -24,7 +30,8 @@ async function processOne() {
     if (normalized.retryable && dispatch.attempts < dispatch.maxAttempts) { dispatch.status = "failed"; dispatch.nextRetryAt = new Date(Date.now() + backoff(dispatch.attempts)); }
     else { dispatch.status = "dead_letter"; dispatch.failedAt = new Date(); }
   }
-  await dispatch.save(); state.lastProgressAt = new Date(); return true;
+  if (!await saveIfOwned(Dispatch, dispatch)) console.warn(JSON.stringify({ event: "transactionalEmail.worker.lease_lost", stage: "save" }));
+  state.lastProgressAt = new Date(); return true;
 }
 async function scrubExpired() { const { Dispatch } = getModels(); await Dispatch.updateMany({ payloadExpiresAt: { $lte: new Date() }, status: { $in: ["provider_accepted", "dead_letter", "cancelled"] } }, { $unset: { protectedPayload: 1 } }); }
 async function tick() { if (!state.running) return; try { let count = 0; while (state.running && count < 20 && await processOne()) count += 1; if (Math.random() < 0.05) await scrubExpired(); } catch (error) { console.error(JSON.stringify({ event: "transactionalEmail.worker.failed", code: error?.code || "EMAIL_WORKER_FAILED" })); } finally { if (state.running) state.timer = setTimeout(tick, 1000); } }

package/src/core/database/policy.js

@@ -10,6 +10,11 @@ const DEFAULTS = Object.freeze({
   maxTimeMS: 5000,
 });
 
+// F4.2: modo de performance por ambiente, escolhido pela plataforma (contexto
+// de delivery → OON_DB_PERFORMANCE_MODE). Só altera maxPoolSize, entre perfis
+// fixos; maxConnecting fica em 2 para limitar a abertura simultânea de conexões.
+const PERFORMANCE_MODES = Object.freeze({ min: 4, normal: 8, ultra: 16 });
+
 function configurationError() {
   const error = new Error("Política de contenção MongoDB inválida.");
   error.code = "DATABASE_POLICY_INVALID";
@@ -32,10 +37,21 @@ function poolOptions(policy = DEFAULTS) {
   return pool;
 }
 
+function performancePolicy(mode = "min") {
+  if (!Object.hasOwn(PERFORMANCE_MODES, mode)) throw configurationError();
+  return validatePolicy({ maxPoolSize: PERFORMANCE_MODES[mode] });
+}
+
+/** Política do processo: o modo vem do ambiente (padrão `min`, a contenção atual). */
+function resolvePolicy(env = process.env) {
+  const mode = env.OON_DB_PERFORMANCE_MODE === undefined || env.OON_DB_PERFORMANCE_MODE === "" ? "min" : env.OON_DB_PERFORMANCE_MODE;
+  return { mode, policy: performancePolicy(mode) };
+}
+
 function boundedMaxTimeMS(value, ceiling = DEFAULTS.maxTimeMS) {
   if (value === undefined || value === 0) return ceiling;
   if (!Number.isSafeInteger(value) || value < 0) throw configurationError();
   return Math.min(value, ceiling);
 }
 
-module.exports = { DEFAULTS, validatePolicy, poolOptions, boundedMaxTimeMS };
+module.exports = { DEFAULTS, PERFORMANCE_MODES, validatePolicy, poolOptions, performancePolicy, resolvePolicy, boundedMaxTimeMS };

package/src/core/middlewares/auth.js

@@ -137,6 +137,23 @@ async function applyEffectiveAccess(usuario) {
       rbacMode: "app-commercial", commercialAccess: { ...authority,
         roleComplete: !local.includes("*") && local.every(p => permissions.includes(p)) } };
   }
+  if (usuario?.integrationAccess && typeof ctx.config.auth?.verifyToken !== "function") {
+    // F4.4: token de integração validado pela Central. Recebe as permissões do
+    // perfil do RBAC do App, sem perfis administrativos nem permissões de
+    // gestão de tenant, usuários, perfis ou publicação.
+    const source = usuario.integrationAccess;
+    const role = roleByCode(source.roleCode);
+    if (!source.tokenId || source.tenantId !== usuario.tenantId || !role) {
+      throw Object.assign(Error("Token de integração inválido."), { statusCode: 403, code: "INTEGRATION_ACCESS_INVALID" });
+    }
+    const local = rolePermissions(role);
+    if (role.admin === true || local.includes("*")) {
+      throw Object.assign(Error("Perfis administrativos não podem ser usados por tokens de integração."), { statusCode: 403, code: "INTEGRATION_ROLE_NOT_ALLOWED" });
+    }
+    const permissions = local.filter((permission) => !/^(tenant|publications|homologation|production|apps|users|roles)\./.test(permission));
+    return { ...usuario, tipo: "integracao", perfil: role.code, roleCode: role.code, permissions, accessStatus: "active",
+      mustChangePassword: false, firstAccessPending: false, rbacMode: "integration-token" };
+  }
   if (usuario?.canonicalAccess && typeof ctx.config.auth?.verifyToken !== "function") {
     const source = usuario.canonicalAccess;
     const role = roleByCode(source.roleCode);