@oondemand/oon-core-back 0.3.56 → 0.3.57

package/bin/integration-worker.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+"use strict";
+
+const { runIntegrationWorker } = require("../src/modules/integrations");
+
+function flag(name) {
+  const args = process.argv.slice(2);
+  const index = args.indexOf(name);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  return value && !value.startsWith("--") ? value : true;
+}
+
+function positive(value) {
+  if (value == null || value === true) return undefined;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`Valor inválido: ${value}.`);
+  return parsed;
+}
+
+runIntegrationWorker({
+  cwd: process.cwd(),
+  once: flag("--once") === true,
+  intervalMs: positive(flag("--interval")),
+  batchSize: positive(flag("--batch")),
+  webhookBatchSize: positive(flag("--webhook-batch")),
+  provider: flag("--provider") === true ? undefined : flag("--provider"),
+}).catch((error) => {
+  console.error(error?.message || error);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oondemand/oon-core-back",
-  "version": "0.3.56",
+  "version": "0.3.57",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oondemand/oon-platform.git",
@@ -9,7 +9,8 @@
   "description": "Core runtime para Centrais Oon: Model Registry, CRUD/RBAC automáticos, módulos opinativos (Omie, Assistentes, Multi-moedas, Esteiras, Documentos) e deploy embutido.",
   "main": "src/index.js",
   "bin": {
-    "oonCore-back": "bin/cli.js"
+    "oonCore-back": "bin/cli.js",
+    "oonCore-integration-worker": "bin/integration-worker.js"
   },
   "files": [
     "bin",

package/src/boot/createApp.js

@@ -9,6 +9,7 @@ const correlationId = require("../core/middlewares/correlationId");
 const requestLog = require("../core/middlewares/requestLog");
 const errorMiddleware = require("../core/middlewares/error");
 const { buildModelRouter } = require("../core/factories/modelRouter");
+const { buildIntegrationRouter, integrationsEnabled } = require("../modules/integrations");
 
 const coreRoutes = require("../api/core.routes");
 const statusRoutes = require("../api/status.routes");
@@ -16,11 +17,6 @@ const authRoutes = require("../api/auth.routes");
 const activationRoutes = require("../api/activation.routes");
 const activationGuard = require("../core/middlewares/activationGuard");
 
-/**
- * Cria a app Express do Core: middlewares transversais, rotas públicas,
- * /core/*, routers de CRUD gerados pelo registry e rotas customizadas
- * (defineRoutes). Tudo derivado do que foi registrado — sem domínio fixo.
- */
 function createApp() {
   const app = express();
 
@@ -31,24 +27,28 @@ function createApp() {
   app.use(correlationId);
   if (process.env.NODE_ENV === "development") app.use(morgan("dev"));
 
-  // Públicas.
   app.use("/", statusRoutes);
   app.use("/ativacao", activationRoutes);
   app.use(activationGuard);
   app.use("/auth", authRoutes);
   app.use("/core", coreRoutes);
 
-  // Log de mutações (após status/core que são GET, antes do domínio).
+  // A engine é montada antes do log genérico: webhooks podem carregar tokens
+  // e payloads sensíveis. A própria engine persiste diagnóstico sanitizado.
+  if (integrationsEnabled(ctx.config)) {
+    const integrationRouter = buildIntegrationRouter();
+    app.use("/integrations", integrationRouter);
+    app.use("/integracoes", integrationRouter);
+  }
+
   app.use(requestLog);
 
-  // CRUD gerado por model registrada.
   for (const entry of registry.listModels()) {
     if (entry.definition.crud?.enabled === false) continue;
     const basePath = entry.definition.basePath || `/${entry.singular}s`;
     app.use(basePath, buildModelRouter(entry));
   }
 
-  // Rotas customizadas (defineRoutes).
   for (const { basePath, expressRouter } of registry.listRoutes()) {
     app.use(basePath, expressRouter);
   }

package/src/boot/database.js

@@ -1,10 +1,9 @@
 const mongoose = require("mongoose");
 const registry = require("../core/registry");
+const ctx = require("../core/context");
+const { getIntegrationModels } = require("../modules/integrations/models");
+const { listIntegrationProviders } = require("../modules/integrations/registry");
 
-/**
- * Conexão com o MongoDB a partir das envs padrão da Central.
- * Extraído de `config/db.js`, sem acoplamento ao domínio.
- */
 function buildMongoUri() {
   const cfg = {
     dbServer: process.env.DB_SERVER,
@@ -24,9 +23,6 @@ function buildMongoUri() {
 }
 
 function connectionOptions() {
-  // MONGO_URI é um contrato completo e pode conter usuário, senha, authSource,
-  // TLS e demais opções. Passar user/pass indefinidos ao Mongoose pode
-  // sobrescrever a autenticação embutida e abrir uma sessão não autenticada.
   if (process.env.MONGO_URI) return {};
 
   const hasUser = Boolean(process.env.DB_USER);
@@ -56,14 +52,6 @@ function shouldSyncDeclaredIndexes() {
   return String(process.env.OON_SYNC_INDEXES ?? "true").toLowerCase() !== "false";
 }
 
-/**
- * Mantém os índices físicos do MongoDB alinhados às models registradas.
- *
- * `createIndexes()` apenas cria índices ausentes e deixa índices removidos do
- * domínio ativos indefinidamente. `syncIndexes()` também elimina esses índices
- * obsoletos, evitando restrições antigas como um `codigo_1` único continuar
- * bloqueando novos registros depois que o campo saiu do manifesto.
- */
 async function syncDeclaredIndexes(entries = registry.listModels()) {
   if (!shouldSyncDeclaredIndexes()) return [];
 
@@ -84,10 +72,31 @@ async function syncDeclaredIndexes(entries = registry.listModels()) {
   return results;
 }
 
+async function syncIntegrationIndexes() {
+  const enabled = Boolean(
+    ctx.config.appManifest?.modules?.integrations
+    || ctx.config.modules?.integrations
+    || listIntegrationProviders().length,
+  );
+  if (!enabled || !shouldSyncDeclaredIndexes()) return [];
+
+  const results = [];
+  for (const model of Object.values(getIntegrationModels())) {
+    const dropped = await model.syncIndexes();
+    const normalized = Array.isArray(dropped) ? dropped : [];
+    results.push({ model: model.modelName, dropped: normalized });
+    if (normalized.length) {
+      console.log(`[OonCore] Índices técnicos obsoletos removidos de ${model.modelName}: ${normalized.join(", ")}`);
+    }
+  }
+  return results;
+}
+
 async function connectDB() {
   const uri = buildMongoUri();
   await mongoose.connect(uri, connectionOptions());
   await syncDeclaredIndexes();
+  await syncIntegrationIndexes();
   console.log(`Conectado ao MongoDB (${databaseLabel(uri)})`);
   return mongoose.connection;
 }
@@ -99,4 +108,5 @@ module.exports = {
   databaseLabel,
   shouldSyncDeclaredIndexes,
   syncDeclaredIndexes,
+  syncIntegrationIndexes,
 };

package/src/index.js

@@ -8,6 +8,7 @@ const fields = require("./core/fields");
 const registry = require("./core/registry");
 const GenericError = require("./core/errors/GenericError");
 const { omie } = require("./modules/omie");
+const integrations = require("./modules/integrations");
 const appManifest = require("./manifest/appManifest");
 const domainManifest = require("./manifest/domainManifest");
 const domainRules = require("./manifest/domainRules");
@@ -71,6 +72,10 @@ module.exports = {
 
   fields,
   omie,
+  integrations,
+  registerIntegrationProvider: integrations.registerIntegrationProvider,
+  enqueueIntegration: integrations.enqueueIntegration,
+  receiveIntegrationWebhook: integrations.receiveWebhook,
   GenericError,
   registry,
-};
+};

package/src/modules/integrations/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const registry = require("./registry");
+const runtime = require("./runtime");
+const sanitizer = require("./sanitizer");
+const models = require("./models");
+const worker = require("./worker");
+const { buildIntegrationRouter } = require("./routes");
+
+function integrationsEnabled(config = {}) {
+  return Boolean(
+    config.appManifest?.modules?.integrations
+    || config.modules?.integrations
+    || registry.listIntegrationProviders().length,
+  );
+}
+
+module.exports = {
+  ...registry,
+  ...runtime,
+  ...sanitizer,
+  ...models,
+  ...worker,
+  buildIntegrationRouter,
+  integrationsEnabled,
+};

package/src/modules/integrations/models.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const mongoose = require("mongoose");
+
+const OUTBOX_STATUSES = ["Pendente", "Processando", "Erro temporário", "Concluído", "Erro definitivo", "Arquivado"];
+const INBOX_STATUSES = ["Pendente", "Processando", "Concluído", "Erro temporário", "Erro definitivo"];
+const EXECUTION_STATUSES = ["Executando", "Concluído", "Concluído com erros", "Erro"];
+
+function jsonField(defaultValue) {
+  return { type: mongoose.Schema.Types.Mixed, default: defaultValue };
+}
+
+function leaseFields() {
+  return {
+    leaseId: { type: String, default: "", index: true },
+    lockedAt: { type: Date, default: null },
+    lockedBy: { type: String, default: "" },
+    leaseExpiresAt: { type: Date, default: null, index: true },
+    heartbeatAt: { type: Date, default: null },
+  };
+}
+
+function model(name, schemaFactory, collection) {
+  return mongoose.models[name] || mongoose.model(name, schemaFactory(), collection);
+}
+
+function outboxSchema() {
+  const schema = new mongoose.Schema({
+    provider: { type: String, required: true, index: true },
+    handler: { type: String, required: true },
+    resource: { type: String, default: "", index: true },
+    operation: { type: String, default: "execute", index: true },
+    aggregateType: { type: String, default: "", index: true },
+    aggregateId: { type: String, default: "", index: true },
+    idempotencyKey: { type: String, required: true, unique: true },
+    payload: jsonField({}),
+    status: { type: String, enum: OUTBOX_STATUSES, default: "Pendente", index: true },
+    previousStatus: { type: String, default: "" },
+    attempts: { type: Number, min: 0, default: 0 },
+    nextAttemptAt: { type: Date, default: Date.now, index: true },
+    lastError: jsonField({}),
+    responseSummary: jsonField({}),
+    completedAt: { type: Date, default: null },
+    archivedAt: { type: Date, default: null },
+    archiveReason: { type: String, default: "" },
+    ...leaseFields(),
+  }, { timestamps: true, minimize: false, strict: true });
+  schema.index({ provider: 1, status: 1, nextAttemptAt: 1, createdAt: 1 });
+  schema.index({ status: 1, leaseExpiresAt: 1 });
+  return schema;
+}
+
+function inboxSchema() {
+  const schema = new mongoose.Schema({
+    provider: { type: String, required: true, index: true },
+    resource: { type: String, default: "", index: true },
+    eventType: { type: String, required: true, index: true },
+    externalEventId: { type: String, default: "" },
+    deduplicationKey: { type: String, required: true, unique: true },
+    payloadHash: { type: String, required: true, index: true },
+    payload: jsonField({}),
+    receivedAt: { type: Date, default: Date.now, index: true },
+    status: { type: String, enum: INBOX_STATUSES, default: "Pendente", index: true },
+    attempts: { type: Number, min: 0, default: 0 },
+    nextAttemptAt: { type: Date, default: Date.now, index: true },
+    processedAt: { type: Date, default: null },
+    lastError: jsonField({}),
+    ...leaseFields(),
+  }, { timestamps: true, minimize: false, strict: true });
+  schema.index({ provider: 1, status: 1, nextAttemptAt: 1, receivedAt: 1 });
+  return schema;
+}
+
+function executionSchema() {
+  const schema = new mongoose.Schema({
+    provider: { type: String, required: true, index: true },
+    resource: { type: String, default: "", index: true },
+    operation: { type: String, default: "execute", index: true },
+    title: { type: String, required: true },
+    status: { type: String, enum: EXECUTION_STATUSES, default: "Executando", index: true },
+    startedAt: { type: Date, default: Date.now, index: true },
+    concludedAt: { type: Date, default: null },
+    durationMs: { type: Number, default: 0 },
+    message: { type: String, default: "" },
+    error: jsonField({}),
+    summary: jsonField({}),
+    metadata: jsonField({}),
+    requests: { type: [mongoose.Schema.Types.Mixed], default: [] },
+    requestCount: { type: Number, default: 0 },
+    requestsLimited: { type: Boolean, default: false },
+    errors: { type: [mongoose.Schema.Types.Mixed], default: [] },
+    errorCount: { type: Number, default: 0 },
+    errorsLimited: { type: Boolean, default: false },
+    items: { type: [mongoose.Schema.Types.Mixed], default: [] },
+    itemCount: { type: Number, default: 0 },
+    itemsLimited: { type: Boolean, default: false },
+  }, { timestamps: true, minimize: false, strict: true });
+  schema.index({ provider: 1, resource: 1, startedAt: -1 });
+  schema.index({ status: 1, startedAt: -1 });
+  return schema;
+}
+
+function getIntegrationModels() {
+  return {
+    Outbox: model("OonIntegrationOutbox", outboxSchema, "oon_integration_outbox"),
+    Inbox: model("OonIntegrationInbox", inboxSchema, "oon_integration_inbox"),
+    Execution: model("OonIntegrationExecution", executionSchema, "oon_integration_executions"),
+  };
+}
+
+module.exports = { EXECUTION_STATUSES, INBOX_STATUSES, OUTBOX_STATUSES, getIntegrationModels };

package/src/modules/integrations/registry.js

@@ -0,0 +1,154 @@
+"use strict";
+
+const coreRegistry = require("../../core/registry");
+const GenericError = require("../../core/errors/GenericError");
+
+const providers = new Map();
+
+function normalizeKey(value, field = "identificador") {
+  const key = String(value || "").trim().toLowerCase();
+  if (!key) {
+    throw new GenericError(`Informe o ${field} da integração.`, { statusCode: 500 });
+  }
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(key)) {
+    throw new GenericError(`${field} inválido: ${key}.`, { statusCode: 500 });
+  }
+  return key;
+}
+
+function normalizeResources(resources = []) {
+  const seen = new Set();
+  return resources.map((resource, index) => {
+    const key = normalizeKey(resource.key, `identificador do recurso ${index + 1}`);
+    if (seen.has(key)) {
+      throw new GenericError(`Recurso duplicado no provedor: ${key}.`, { statusCode: 500 });
+    }
+    seen.add(key);
+    return {
+      ...resource,
+      key,
+      label: String(resource.label || key),
+      order: Number(resource.order ?? (index + 1) * 10),
+      includeInFullSync: resource.includeInFullSync !== false,
+    };
+  });
+}
+
+function metadataFor(provider) {
+  return {
+    id: provider.key,
+    key: provider.key,
+    name: provider.key,
+    label: provider.label,
+    description: provider.description || "",
+    status: typeof provider.enabled === "function"
+      ? (provider.enabled() ? "ativo" : "inativo")
+      : (provider.enabled === false ? "inativo" : "ativo"),
+    capabilities: [...(provider.capabilities || [])],
+    resources: provider.resources.map((resource) => ({
+      key: resource.key,
+      label: resource.label,
+      description: resource.description || "",
+      order: resource.order,
+      includeInFullSync: resource.includeInFullSync,
+      operations: [...(resource.operations || [resource.syncHandler ? "sync" : "execute"])],
+    })),
+  };
+}
+
+function registerIntegrationProvider(definition = {}) {
+  const key = normalizeKey(definition.key, "identificador do provedor");
+  if (providers.has(key) && definition.replace !== true) {
+    throw new GenericError(`Provedor de integração já registrado: ${key}.`, { statusCode: 500 });
+  }
+
+  const provider = {
+    ...definition,
+    key,
+    label: String(definition.label || key),
+    resources: normalizeResources(definition.resources || []),
+    handlers: { ...(definition.handlers || {}) },
+    webhooks: { ...(definition.webhooks || {}) },
+    maxAttempts: Math.max(1, Number(definition.maxAttempts || 5)),
+    retryPolicy: {
+      strategy: "exponential",
+      initialMs: 60_000,
+      maxMs: 21_600_000,
+      jitter: true,
+      ...(definition.retryPolicy || {}),
+    },
+  };
+
+  providers.set(key, provider);
+  coreRegistry.registerIntegration(key, metadataFor(provider));
+  return provider;
+}
+
+function getIntegrationProvider(key) {
+  const normalized = normalizeKey(key, "identificador do provedor");
+  const provider = providers.get(normalized);
+  if (!provider) {
+    throw new GenericError(`Provedor de integração não registrado: ${normalized}.`, {
+      statusCode: 404,
+    });
+  }
+  return provider;
+}
+
+function listIntegrationProviders() {
+  return [...providers.values()]
+    .map(metadataFor)
+    .sort((left, right) => left.label.localeCompare(right.label, "pt-BR"));
+}
+
+function resolveIntegrationHandler(providerKey, handlerKey) {
+  const provider = getIntegrationProvider(providerKey);
+  const key = String(handlerKey || "").trim();
+  const handler = provider.handlers[key];
+  if (!key || typeof handler !== "function") {
+    throw new GenericError(
+      `Operação ${key || "não informada"} não registrada para ${provider.label}.`,
+      { statusCode: 422 },
+    );
+  }
+  return { provider, handler, handlerKey: key };
+}
+
+function resolveWebhookHandler(providerKey, eventType) {
+  const provider = getIntegrationProvider(providerKey);
+  const type = String(eventType || "").trim();
+  const handler = provider.webhooks[type] || provider.webhooks["*"] || provider.handleWebhook;
+  if (typeof handler !== "function") {
+    throw new GenericError(`Evento ${type || "não informado"} não suportado por ${provider.label}.`, {
+      statusCode: 422,
+    });
+  }
+  return { provider, handler, eventType: type };
+}
+
+function findResource(providerKey, resourceKey) {
+  const provider = getIntegrationProvider(providerKey);
+  const key = normalizeKey(resourceKey, "identificador do recurso");
+  const resource = provider.resources.find((candidate) => candidate.key === key);
+  if (!resource) {
+    throw new GenericError(`Recurso ${key} não registrado para ${provider.label}.`, {
+      statusCode: 404,
+    });
+  }
+  return { provider, resource };
+}
+
+function resetIntegrationProviders() {
+  providers.clear();
+}
+
+module.exports = {
+  findResource,
+  getIntegrationProvider,
+  listIntegrationProviders,
+  normalizeKey,
+  registerIntegrationProvider,
+  resetIntegrationProviders,
+  resolveIntegrationHandler,
+  resolveWebhookHandler,
+};

package/src/modules/integrations/routes.js

@@ -0,0 +1,167 @@
+"use strict";
+
+const express = require("express");
+const auth = require("../../core/middlewares/auth");
+const { rbac } = require("../../core/middlewares/rbac");
+const { asyncHandler } = require("../../core/utils/helpers");
+const { getIntegrationModels } = require("./models");
+const { getIntegrationProvider, listIntegrationProviders } = require("./registry");
+const {
+  archiveIntegrationTicket,
+  integrationHealth,
+  processIntegrationQueue,
+  processWebhookInbox,
+  receiveWebhook,
+  reprocessIntegrationTicket,
+  synchronizeAll,
+  synchronizeResource,
+} = require("./runtime");
+const { sanitizeIntegrationValue } = require("./sanitizer");
+
+const READ_ROLES = ["admin", "desenvolvedor"];
+const WRITE_ROLES = ["admin", "desenvolvedor"];
+
+function number(value, fallback, max = 100) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.min(max, Math.max(1, parsed)) : fallback;
+}
+
+function pagination(query = {}) {
+  const limit = number(query.limit || query.pageSize, 20, 200);
+  const page = number(query.page || query.pageIndex, 1, 100_000);
+  return { limit, page, skip: (page - 1) * limit };
+}
+
+function buildIntegrationRouter() {
+  const router = express.Router();
+
+  router.post("/webhooks/:provider/:token", asyncHandler(async (req, res) => {
+    const event = await receiveWebhook({
+      provider: req.params.provider,
+      token: req.params.token,
+      headers: req.headers,
+      payload: req.body,
+      resource: req.query.resource,
+      eventType: req.body?.eventType || req.body?.event_type || req.body?.topic || "unknown",
+      externalEventId: req.body?.eventId || req.body?.event_id || req.body?.id,
+    });
+    res.status(202).json({ accepted: true, id: String(event._id), duplicate: event.status !== "Pendente" });
+  }));
+
+  router.use(auth);
+  router.get("/providers", rbac(READ_ROLES), (_req, res) => {
+    res.json({ results: listIntegrationProviders() });
+  });
+  router.get("/providers/:provider/catalog", rbac(READ_ROLES), (req, res) => {
+    const provider = getIntegrationProvider(req.params.provider);
+    const metadata = listIntegrationProviders().find((item) => item.key === provider.key);
+    res.json({ provider: provider.key, resources: metadata?.resources || [] });
+  });
+  router.get("/health", rbac(READ_ROLES), asyncHandler(async (_req, res) => {
+    res.json({ results: await integrationHealth() });
+  }));
+
+  router.get("/history", rbac(READ_ROLES), asyncHandler(async (req, res) => {
+    const { Execution } = getIntegrationModels();
+    const { limit, page, skip } = pagination(req.query);
+    const filter = {};
+    for (const field of ["provider", "resource", "operation", "status"]) {
+      if (req.query[field]) filter[field] = String(req.query[field]);
+    }
+    const [results, totalItems] = await Promise.all([
+      Execution.find(filter).sort({ startedAt: -1 }).skip(skip).limit(limit).lean(),
+      Execution.countDocuments(filter),
+    ]);
+    res.json({
+      results: sanitizeIntegrationValue(results),
+      pagination: {
+        currentPage: page,
+        totalItems,
+        totalPages: Math.ceil(totalItems / limit),
+        itemsPerPage: limit,
+      },
+    });
+  }));
+
+  router.get("/queue", rbac(READ_ROLES), asyncHandler(async (req, res) => {
+    const { Outbox } = getIntegrationModels();
+    const { limit, page, skip } = pagination(req.query);
+    const filter = {};
+    for (const field of ["provider", "resource", "operation", "status", "aggregateType", "aggregateId"]) {
+      if (req.query[field]) filter[field] = String(req.query[field]);
+    }
+    const [results, totalItems] = await Promise.all([
+      Outbox.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).lean(),
+      Outbox.countDocuments(filter),
+    ]);
+    res.json({
+      results: sanitizeIntegrationValue(results),
+      pagination: {
+        currentPage: page,
+        totalItems,
+        totalPages: Math.ceil(totalItems / limit),
+        itemsPerPage: limit,
+      },
+    });
+  }));
+
+  router.get("/events", rbac(READ_ROLES), asyncHandler(async (req, res) => {
+    const { Inbox } = getIntegrationModels();
+    const { limit, page, skip } = pagination(req.query);
+    const filter = {};
+    for (const field of ["provider", "resource", "eventType", "status"]) {
+      if (req.query[field]) filter[field] = String(req.query[field]);
+    }
+    const [results, totalItems] = await Promise.all([
+      Inbox.find(filter).sort({ receivedAt: -1 }).skip(skip).limit(limit).lean(),
+      Inbox.countDocuments(filter),
+    ]);
+    res.json({
+      results: sanitizeIntegrationValue(results),
+      pagination: {
+        currentPage: page,
+        totalItems,
+        totalPages: Math.ceil(totalItems / limit),
+        itemsPerPage: limit,
+      },
+    });
+  }));
+
+  router.post("/providers/:provider/resources/:resource/sync", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
+    const result = await synchronizeResource(req.params.provider, req.params.resource, {
+      payload: req.body,
+      metadata: { source: "api", requestId: req.requestId || "", user: req.usuario?.email || "" },
+    });
+    res.status(200).json(result);
+  }));
+  router.post("/providers/:provider/sync-all", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
+    const result = await synchronizeAll(req.params.provider, {
+      payload: req.body,
+      metadata: { source: "api", requestId: req.requestId || "", user: req.usuario?.email || "" },
+    });
+    res.status(result.status === "Concluído" ? 200 : 207).json(result);
+  }));
+  router.post("/queue/process", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
+    res.json(await processIntegrationQueue({ provider: req.body?.provider, limit: req.body?.limit }));
+  }));
+  router.post("/events/process", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
+    res.json(await processWebhookInbox({ provider: req.body?.provider, limit: req.body?.limit }));
+  }));
+  router.post("/queue/:id/archive", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
+    res.json(await archiveIntegrationTicket(req.params.id, req.body?.reason));
+  }));
+  router.post("/queue/:id/reprocess", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
+    res.json(await reprocessIntegrationTicket(req.params.id));
+  }));
+  router.post("/actions/process-active", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
+    const [queue, events] = await Promise.all([
+      processIntegrationQueue({ limit: req.body?.limit }),
+      processWebhookInbox({ limit: req.body?.eventLimit }),
+    ]);
+    res.json({ queue, events });
+  }));
+
+  return router;
+}
+
+module.exports = { buildIntegrationRouter };