@oondemand/oon-core-back 0.5.5 → 0.6.0

package/src/modules/integrations/registry.js

@@ -1,171 +0,0 @@
-"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 publicConfiguration(configuration) {
-  if (!configuration) return null;
-  return {
-    enabled: configuration.enabled !== false,
-    multiInstance: configuration.multiInstance === true,
-    fields: (configuration.fields || []).map((field) => ({
-      key: field.key,
-      label: field.label || field.key,
-      type: field.type || "text",
-      readOnly: field.readOnly === true,
-      writeOnly: field.writeOnly === true,
-      options: field.options || undefined,
-    })),
-  };
-}
-
-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 || [])],
-    configuration: publicConfiguration(provider.configuration),
-    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

@@ -1,343 +0,0 @@
-"use strict";
-
-const express = require("express");
-const mongoose = require("mongoose");
-const GenericError = require("../../core/errors/GenericError");
-const auth = require("../../core/middlewares/auth");
-const { rbac } = require("../../core/middlewares/rbac");
-const { asyncHandler } = require("../../core/utils/helpers");
-const { getIntegrationModels, OUTBOX_STATUSES } = 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"];
-const WEBHOOK_AUTO_PROCESS_LIMIT = 50;
-const webhookProvidersPending = new Set();
-let webhookProcessingScheduled = false;
-
-function scheduleWebhookProcessing(provider) {
-  const providerKey = String(provider || "").trim().toLowerCase();
-  if (!providerKey) return;
-
-  webhookProvidersPending.add(providerKey);
-  if (webhookProcessingScheduled) return;
-  webhookProcessingScheduled = true;
-
-  setImmediate(async () => {
-    const providers = [...webhookProvidersPending];
-    webhookProvidersPending.clear();
-    try {
-      for (const currentProvider of providers) {
-        try {
-          const events = await processWebhookInbox({
-            provider: currentProvider,
-            limit: WEBHOOK_AUTO_PROCESS_LIMIT,
-          });
-          const queue = await processIntegrationQueue({
-            provider: currentProvider,
-            limit: WEBHOOK_AUTO_PROCESS_LIMIT,
-          });
-
-          if (
-            (Array.isArray(events?.results) && events.results.length >= WEBHOOK_AUTO_PROCESS_LIMIT)
-            || (Array.isArray(queue?.results) && queue.results.length >= WEBHOOK_AUTO_PROCESS_LIMIT)
-          ) {
-            webhookProvidersPending.add(currentProvider);
-          }
-        } catch (error) {
-          console.error(
-            `[oon-integrations] Falha ao processar webhook automaticamente para ${currentProvider}: ${String(error?.message || error)}`,
-          );
-        }
-      }
-    } finally {
-      webhookProcessingScheduled = false;
-      if (webhookProvidersPending.size) {
-        scheduleWebhookProcessing([...webhookProvidersPending][0]);
-      }
-    }
-  });
-}
-
-function publicWebhookUrl(path) {
-  const webhookPath = String(path || "").trim();
-  const publicAppUrl = String(process.env.PUBLIC_APP_URL || "").trim();
-  if (!webhookPath || !publicAppUrl) return webhookPath;
-
-  try {
-    const url = new URL(publicAppUrl);
-    const basePath = url.pathname.replace(/\/+$/, "");
-    const apiBasePath = basePath.endsWith("/api") ? basePath : `${basePath}/api`;
-    const relativePath = webhookPath.startsWith("/") ? webhookPath : `/${webhookPath}`;
-    url.pathname = `${apiBasePath}${relativePath}`.replace(/\/{2,}/g, "/");
-    url.search = "";
-    url.hash = "";
-    return url.toString();
-  } catch {
-    return webhookPath;
-  }
-}
-
-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 escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function buildQueueFilter(query = {}, options = {}) {
-  const includeStatus = options.includeStatus !== false;
-  const filter = {};
-  for (const field of ["provider", "resource", "operation", "aggregateType", "aggregateId"]) {
-    if (query[field]) filter[field] = String(query[field]);
-  }
-  if (includeStatus && query.status) filter.status = String(query.status);
-
-  const search = String(query.search || "").trim().slice(0, 160);
-  if (search) {
-    const pattern = new RegExp(escapeRegExp(search), "i");
-    const clauses = [
-      { handler: pattern },
-      { resource: pattern },
-      { operation: pattern },
-      { aggregateType: pattern },
-      { aggregateId: pattern },
-      { idempotencyKey: pattern },
-    ];
-    if (mongoose.isValidObjectId(search)) clauses.unshift({ _id: new mongoose.Types.ObjectId(search) });
-    filter.$or = clauses;
-  }
-  return filter;
-}
-
-async function queueStatusSummary(Outbox, filter = {}) {
-  const rows = await Outbox.aggregate([
-    { $match: filter },
-    { $group: { _id: "$status", count: { $sum: 1 } } },
-  ]);
-  const statuses = Object.fromEntries(OUTBOX_STATUSES.map((status) => [status, 0]));
-  for (const row of rows) statuses[String(row._id)] = Number(row.count || 0);
-  return {
-    total: Object.values(statuses).reduce((sum, count) => sum + Number(count || 0), 0),
-    statuses,
-  };
-}
-
-function requireProviderExtension(provider, method, message) {
-  if (typeof provider[method] !== "function") {
-    throw new GenericError(message || `O provedor ${provider.label} não oferece ${method}.`, {
-      statusCode: 404,
-    });
-  }
-  return provider[method].bind(provider);
-}
-
-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(200).json({ accepted: true, id: String(event._id), duplicate: event.status !== "Pendente" });
-    scheduleWebhookProcessing(req.params.provider);
-  }));
-
-  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("/providers/:provider/configuration", rbac(READ_ROLES), asyncHandler(async (req, res) => {
-    const provider = getIntegrationProvider(req.params.provider);
-    const getConfiguration = requireProviderExtension(
-      provider,
-      "getConfiguration",
-      `O provedor ${provider.label} não possui configuração gerenciada pelo Core.`,
-    );
-    res.json({ provider: provider.key, instances: sanitizeIntegrationValue(await getConfiguration()) });
-  }));
-  router.put("/providers/:provider/configuration/:instanceId", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
-    const provider = getIntegrationProvider(req.params.provider);
-    const saveConfiguration = requireProviderExtension(provider, "saveConfiguration");
-    const saved = await saveConfiguration(req.params.instanceId, req.body || {});
-    res.json({ provider: provider.key, configuration: sanitizeIntegrationValue(saved) });
-  }));
-  router.post("/providers/:provider/configuration/:instanceId/test", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
-    const provider = getIntegrationProvider(req.params.provider);
-    const testConnection = requireProviderExtension(provider, "testConnection");
-    res.json(await testConnection(req.params.instanceId, {
-      input: req.body || {},
-      source: "api",
-      requestId: req.requestId || "",
-    }));
-  }));
-  router.get("/providers/:provider/configuration/:instanceId/webhook", rbac(READ_ROLES), asyncHandler(async (req, res) => {
-    const provider = getIntegrationProvider(req.params.provider);
-    const getWebhookAccess = requireProviderExtension(provider, "getWebhookAccess");
-    const access = await getWebhookAccess(req.params.instanceId);
-    res.json({ provider: provider.key, ...access, webhookPath: publicWebhookUrl(access.webhookPath) });
-  }));
-  router.post("/providers/:provider/configuration/:instanceId/webhook/rotate", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
-    const provider = getIntegrationProvider(req.params.provider);
-    const rotateWebhookToken = requireProviderExtension(provider, "rotateWebhookToken");
-    const access = await rotateWebhookToken(req.params.instanceId);
-    res.json({ provider: provider.key, ...access, webhookPath: publicWebhookUrl(access.webhookPath) });
-  }));
-  router.get("/providers/:provider/mappings", rbac(READ_ROLES), asyncHandler(async (req, res) => {
-    const provider = getIntegrationProvider(req.params.provider);
-    const describe = requireProviderExtension(provider, "describe");
-    res.json({ provider: provider.key, ...sanitizeIntegrationValue(await describe()) });
-  }));
-  router.post("/providers/:provider/calls/:call", rbac(WRITE_ROLES), asyncHandler(async (req, res) => {
-    const provider = getIntegrationProvider(req.params.provider);
-    const executeCall = requireProviderExtension(provider, "executeCall");
-    res.json(await executeCall(req.params.call, req.body?.input || req.body || {}, {
-      instanceId: req.body?.instanceId || "default",
-      source: "api",
-      requestId: req.requestId || "",
-    }));
-  }));
-  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 = buildQueueFilter(req.query);
-    const summaryFilter = buildQueueFilter(req.query, { includeStatus: false });
-    const [results, totalItems, summary] = await Promise.all([
-      Outbox.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).lean(),
-      Outbox.countDocuments(filter),
-      queueStatusSummary(Outbox, summaryFilter),
-    ]);
-    res.json({
-      results: sanitizeIntegrationValue(results),
-      summary,
-      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,
-  buildQueueFilter,
-  publicWebhookUrl,
-  queueStatusSummary,
-  scheduleWebhookProcessing,
-};

package/src/modules/integrations/runtime/inbox.js

@@ -1,134 +0,0 @@
-"use strict";
-
-const GenericError = require("../../../core/errors/GenericError");
-const { getIntegrationModels } = require("../models");
-const { getIntegrationProvider, resolveWebhookHandler } = require("../registry");
-const { sanitizeIntegrationError, sanitizeIntegrationValue } = require("../sanitizer");
-const { acquireNext, finalizeLease, leaseHeartbeat } = require("./lease");
-const { runTrackedOperation } = require("./tracking");
-const { DEFAULT_LEASE_MS, calculateBackoff, classifyError, isEnabled, payloadHash, workerId } = require("./utils");
-
-async function receiveWebhook(input) {
-  const provider = getIntegrationProvider(input.provider);
-  let verificationMetadata = {};
-  if (typeof provider.verifyWebhook === "function") {
-    const verification = await provider.verifyWebhook({
-      token: input.token,
-      headers: input.headers || {},
-      payload: input.payload,
-    });
-    const accepted = verification === true || verification?.accepted === true;
-    if (!accepted) throw new GenericError("Webhook de integração não autorizado.", { statusCode: 401 });
-    verificationMetadata = sanitizeIntegrationValue(verification?.metadata || {});
-  }
-
-  const normalized = typeof provider.normalizeWebhook === "function"
-    ? await provider.normalizeWebhook({ ...input, metadata: verificationMetadata })
-    : input;
-  const sanitizedPayload = sanitizeIntegrationValue(normalized.payload || {});
-  const hash = payloadHash(sanitizedPayload);
-  const externalEventId = String(normalized.externalEventId || "").trim();
-  const deduplicationKey = `${provider.key}:${externalEventId || hash}`;
-  const { Inbox } = getIntegrationModels();
-  return Inbox.findOneAndUpdate(
-    { deduplicationKey },
-    {
-      $setOnInsert: {
-        provider: provider.key,
-        resource: String(normalized.resource || ""),
-        eventType: String(normalized.eventType || "unknown"),
-        externalEventId,
-        deduplicationKey,
-        payloadHash: hash,
-        payload: sanitizedPayload,
-        metadata: sanitizeIntegrationValue({
-          ...verificationMetadata,
-          ...(normalized.metadata || {}),
-        }),
-        receivedAt: new Date(),
-        status: "Pendente",
-        attempts: 0,
-        nextAttemptAt: new Date(),
-      },
-    },
-    { upsert: true, new: true, setDefaultsOnInsert: true },
-  ).lean();
-}
-
-async function processWebhookInbox(options = {}) {
-  const { Inbox } = getIntegrationModels();
-  const limit = Math.min(500, Math.max(1, Number(options.limit || 20)));
-  const worker = options.worker || workerId("inbox");
-  const leaseMs = Number(options.leaseMs || DEFAULT_LEASE_MS);
-  const results = [];
-
-  for (let index = 0; index < limit; index += 1) {
-    const query = { status: { $in: ["Pendente", "Erro temporário", "Processando"] } };
-    if (options.provider) query.provider = String(options.provider).trim().toLowerCase();
-    const event = await acquireNext(Inbox, query, { worker, leaseMs });
-    if (!event) break;
-    const pulse = leaseHeartbeat(Inbox, event, options);
-    pulse.start();
-    let provider;
-    try {
-      const resolved = resolveWebhookHandler(event.provider, event.eventType);
-      provider = resolved.provider;
-      const handler = resolved.handler;
-      if (!isEnabled(provider)) {
-        throw new GenericError(`A integração ${provider.label} está desativada.`, { statusCode: 503 });
-      }
-      const tracked = await runTrackedOperation({
-        provider: provider.key,
-        resource: event.resource || "",
-        operation: "webhook",
-        title: `${provider.label}: webhook ${event.eventType}`,
-        metadata: {
-          source: "inbox",
-          inboxId: String(event._id),
-          externalEventId: event.externalEventId || "",
-          ...sanitizeIntegrationValue(event.metadata || {}),
-        },
-        runner: (trace) => handler(event, {
-          ...options,
-          ...trace,
-          provider,
-          heartbeat: pulse.beat,
-          sanitize: sanitizeIntegrationValue,
-        }),
-      });
-      const committed = await finalizeLease(Inbox, event, {
-        status: "Concluído",
-        processedAt: new Date(),
-        lastError: {},
-        nextAttemptAt: null,
-      });
-      if (!committed) {
-        throw new GenericError("Resultado do webhook ignorado porque o lease expirou.", { statusCode: 409 });
-      }
-      results.push({ id: String(event._id), status: "Concluído", response: tracked.result });
-    } catch (error) {
-      const effectiveProvider = provider || { maxAttempts: 1, retryPolicy: { jitter: false } };
-      const classification = classifyError(effectiveProvider, error, Number(event.attempts || 1));
-      const committed = await finalizeLease(Inbox, event, {
-        status: classification.definitive ? "Erro definitivo" : "Erro temporário",
-        lastError: sanitizeIntegrationError(error),
-        nextAttemptAt: classification.definitive
-          ? null
-          : new Date(Date.now() + calculateBackoff(event.attempts, effectiveProvider.retryPolicy)),
-      });
-      if (!committed) {
-        throw new GenericError("Erro do webhook ignorado porque o lease expirou.", { statusCode: 409 });
-      }
-      results.push({
-        id: String(event._id),
-        status: classification.definitive ? "Erro definitivo" : "Erro temporário",
-        error: sanitizeIntegrationError(error),
-      });
-    } finally {
-      pulse.stop();
-    }
-  }
-  return { processed: results.filter((item) => item.status === "Concluído").length, results };
-}
-
-module.exports = { processWebhookInbox, receiveWebhook };