@oondemand/oon-core-back 0.3.55 → 0.3.57

package/src/modules/integrations/sanitizer.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const SENSITIVE_KEY = /(authorization|cookie|password|passwd|secret|token|api[-_]?key|app[-_]?key|app[-_]?secret|private[-_]?key|credential|senha)/i;
+const DEFAULTS = {
+  maxDepth: 6,
+  maxArrayItems: 20,
+  maxObjectKeys: 100,
+  maxStringLength: 4000,
+};
+
+function truncate(value, limit) {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit)}…[truncado:${value.length - limit}]`;
+}
+
+function sanitizeIntegrationValue(value, options = {}, state = { depth: 0, seen: new WeakSet() }) {
+  const config = { ...DEFAULTS, ...options };
+  if (value == null || typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "string") return truncate(value, config.maxStringLength);
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: truncate(String(value.message || value), config.maxStringLength),
+      code: value.code,
+      statusCode: value.statusCode || value.response?.status,
+    };
+  }
+  if (typeof value !== "object") return truncate(String(value), config.maxStringLength);
+  if (state.depth >= config.maxDepth) return "[limite-de-profundidade]";
+  if (state.seen.has(value)) return "[referência-circular]";
+  state.seen.add(value);
+
+  const nextState = { depth: state.depth + 1, seen: state.seen };
+  if (Array.isArray(value)) {
+    const items = value
+      .slice(0, config.maxArrayItems)
+      .map((item) => sanitizeIntegrationValue(item, config, nextState));
+    if (value.length > config.maxArrayItems) {
+      items.push({ _truncated: value.length - config.maxArrayItems });
+    }
+    return items;
+  }
+
+  const output = {};
+  const entries = Object.entries(value).slice(0, config.maxObjectKeys);
+  for (const [key, item] of entries) {
+    output[key] = SENSITIVE_KEY.test(key)
+      ? "[REDACTED]"
+      : sanitizeIntegrationValue(item, config, nextState);
+  }
+  if (Object.keys(value).length > config.maxObjectKeys) {
+    output._truncatedKeys = Object.keys(value).length - config.maxObjectKeys;
+  }
+  return output;
+}
+
+function sanitizeIntegrationError(error, options = {}) {
+  const sanitized = sanitizeIntegrationValue(error, options);
+  if (typeof sanitized === "string") return { message: sanitized };
+  return {
+    name: sanitized?.name || error?.name || "Error",
+    message: sanitized?.message || String(error?.message || error || "Falha desconhecida."),
+    code: sanitized?.code || error?.code,
+    statusCode: sanitized?.statusCode || error?.statusCode || error?.response?.status,
+  };
+}
+
+module.exports = {
+  DEFAULT_SANITIZE_OPTIONS: DEFAULTS,
+  SENSITIVE_KEY,
+  sanitizeIntegrationError,
+  sanitizeIntegrationValue,
+};

package/src/modules/integrations/worker.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const { loadCentral } = require("../../boot/loadCentral");
+const { connectDB } = require("../../boot/database");
+const { listIntegrationProviders } = require("./registry");
+const { processIntegrationQueue, processWebhookInbox } = require("./runtime");
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function drainOnce(options = {}) {
+  const providers = options.provider
+    ? [{ key: String(options.provider).trim().toLowerCase() }]
+    : listIntegrationProviders();
+  const results = [];
+  for (const provider of providers) {
+    const [queue, events] = await Promise.all([
+      processIntegrationQueue({ ...options, provider: provider.key, limit: options.batchSize || options.limit || 20 }),
+      processWebhookInbox({ ...options, provider: provider.key, limit: options.webhookBatchSize || 20 }),
+    ]);
+    results.push({ provider: provider.key, queue, events });
+  }
+  return results;
+}
+
+async function runIntegrationWorker(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  loadCentral(cwd);
+  await connectDB();
+  const once = options.once === true;
+  const intervalMs = Math.max(
+    1000,
+    Number(options.intervalMs || process.env.OON_INTEGRATION_WORKER_INTERVAL_MS || 15_000),
+  );
+  let stopping = false;
+  const stop = () => { stopping = true; };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+
+  do {
+    const results = await drainOnce(options);
+    if (options.logger !== false) {
+      const processed = results.reduce(
+        (sum, item) => sum + item.queue.processed + item.events.processed,
+        0,
+      );
+      if (processed) console.log(`[integration-worker] processados=${processed}`);
+    }
+    if (!once && !stopping) await delay(intervalMs);
+  } while (!once && !stopping);
+
+  return { stopped: true };
+}
+
+module.exports = { drainOnce, runIntegrationWorker };