@oondemand/oon-core-back 0.3.72 → 0.3.73

package/package.json

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

package/src/modules/integrations/routes.js

@@ -22,6 +22,72 @@ 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);
@@ -98,7 +164,8 @@ function buildIntegrationRouter() {
       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" });
+    res.status(200).json({ accepted: true, id: String(event._id), duplicate: event.status !== "Pendente" });
+    scheduleWebhookProcessing(req.params.provider);
   }));
 
   router.use(auth);
@@ -137,12 +204,14 @@ function buildIntegrationRouter() {
   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");
-    res.json({ provider: provider.key, ...await getWebhookAccess(req.params.instanceId) });
+    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");
-    res.json({ provider: provider.key, ...await rotateWebhookToken(req.params.instanceId) });
+    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);
@@ -265,4 +334,10 @@ function buildIntegrationRouter() {
   return router;
 }
 
-module.exports = { buildIntegrationRouter, buildQueueFilter, queueStatusSummary };
+module.exports = {
+  buildIntegrationRouter,
+  buildQueueFilter,
+  publicWebhookUrl,
+  queueStatusSummary,
+  scheduleWebhookProcessing,
+};