@oondemand/oon-core-back 0.3.64 → 0.3.66

package/package.json

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

package/src/modules/integrations/routes.js

@@ -1,11 +1,12 @@
 "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 } = require("./models");
+const { getIntegrationModels, OUTBOX_STATUSES } = require("./models");
 const { getIntegrationProvider, listIntegrationProviders } = require("./registry");
 const {
   archiveIntegrationTicket,
@@ -33,6 +34,48 @@ function pagination(query = {}) {
   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}.`, {
@@ -144,16 +187,16 @@ function buildIntegrationRouter() {
   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([
+    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,
@@ -222,4 +265,4 @@ function buildIntegrationRouter() {
   return router;
 }
 
-module.exports = { buildIntegrationRouter };
+module.exports = { buildIntegrationRouter, buildQueueFilter, queueStatusSummary };

package/src/modules/omie/client.js

@@ -95,6 +95,22 @@ function responseError(body, statusCode) {
   });
 }
 
+function normalizedStringList(value) {
+  const values = Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
+  return values.map((item) => String(item).trim()).filter(Boolean);
+}
+
+function isConfiguredEmptyResult(callDefinition = {}, body = {}) {
+  const code = String(body?.faultcode ?? body?.code ?? body?.codigo_status ?? "").trim();
+  const description = String(
+    body?.faultstring ?? body?.description ?? body?.descricao_status ?? "",
+  ).trim();
+  const codes = normalizedStringList(callDefinition.emptyResultFaultCodes);
+  const messages = normalizedStringList(callDefinition.emptyResultMessages);
+  return (code && codes.includes(code))
+    || (description && messages.some((message) => description.includes(message)));
+}
+
 function retryableTransportError(error) {
   const statusCode = Number(error?.response?.status || error?.statusCode || 0);
   return RETRYABLE_HTTP.has(statusCode)
@@ -166,9 +182,10 @@ function createOmieClient(options = {}) {
       app_secret: appSecret,
       param: Array.isArray(resolvedParam) ? resolvedParam : [resolvedParam],
     };
+    const callMaxAttempts = Math.max(1, Number(callDefinition.maxAttempts ?? maxAttempts));
     let lastError;
 
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    for (let attempt = 1; attempt <= callMaxAttempts; attempt += 1) {
       const startedAt = Date.now();
       const trace = {
         endpoint: callDefinition.endpoint,
@@ -185,14 +202,18 @@ function createOmieClient(options = {}) {
         });
         const status = Number(response?.status || 200);
         const data = response?.data ?? {};
+        const emptyResult = isConfiguredEmptyResult(callDefinition, data);
         trace.httpStatus = status;
         trace.response = sanitizeIntegrationValue(data);
         trace.durationMs = Date.now() - startedAt;
-        const normalized = responseError(data, status);
-        if (normalized) throw normalized;
+        trace.emptyResult = emptyResult;
+        if (!emptyResult) {
+          const normalized = responseError(data, status);
+          if (normalized) throw normalized;
+        }
         trace.status = "success";
         context.recordRequest?.(trace);
-        return { data, trace };
+        return { data, trace, emptyResult };
       } catch (error) {
         const normalized = error instanceof OmieApiError
           ? error
@@ -209,7 +230,7 @@ function createOmieClient(options = {}) {
         context.recordRequest?.(trace);
         normalized.trace = trace;
         lastError = normalized;
-        if (!normalized.retryable || attempt >= maxAttempts) throw normalized;
+        if (!normalized.retryable || attempt >= callMaxAttempts) throw normalized;
         const delay = Math.min(5_000, retryInitialMs * (2 ** (attempt - 1)));
         await wait(delay);
       }
@@ -253,8 +274,9 @@ module.exports = {
   OmieApiError,
   createOmieClient,
   getPath,
+  isConfiguredEmptyResult,
   normalizeEndpoint,
   resolveCallParam,
   resolveTemplate,
   responseError,
-};
+};