@oondemand/oon-core-back 0.3.56 → 0.3.58

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

@@ -0,0 +1,85 @@
+"use strict";
+
+const GenericError = require("../../../core/errors/GenericError");
+const { getIntegrationModels } = require("../models");
+const { findResource, getIntegrationProvider, listIntegrationProviders, resolveIntegrationHandler } = require("../registry");
+const { sanitizeIntegrationError, sanitizeIntegrationValue } = require("../sanitizer");
+const { runTrackedOperation } = require("./tracking");
+const { isEnabled } = require("./utils");
+
+async function synchronizeResource(providerKey, resourceKey, options = {}) {
+  const { provider, resource } = findResource(providerKey, resourceKey);
+  if (!isEnabled(provider)) {
+    throw new GenericError(`A integração ${provider.label} está desativada.`, { statusCode: 503 });
+  }
+  const handlerKey = resource.syncHandler || resource.handler;
+  const { handler } = resolveIntegrationHandler(provider.key, handlerKey);
+  return runTrackedOperation({
+    provider: provider.key,
+    resource: resource.key,
+    operation: "sync",
+    title: resource.syncTitle || `Sincronização de ${resource.label}`,
+    metadata: options.metadata || {},
+    runner: (context) => handler({
+      provider: provider.key,
+      handler: handlerKey,
+      resource: resource.key,
+      operation: "sync",
+      payload: sanitizeIntegrationValue(options.payload || {}),
+    }, { ...options, ...context, provider, resource }),
+  });
+}
+
+async function synchronizeAll(providerKey, options = {}) {
+  const provider = getIntegrationProvider(providerKey);
+  const resources = provider.resources
+    .filter((resource) => resource.includeInFullSync && (resource.syncHandler || resource.handler))
+    .sort((left, right) => left.order - right.order);
+  const results = [];
+  for (const resource of resources) {
+    try {
+      results.push({
+        resource: resource.key,
+        ok: true,
+        result: await synchronizeResource(provider.key, resource.key, options),
+      });
+    } catch (error) {
+      results.push({ resource: resource.key, ok: false, error: sanitizeIntegrationError(error) });
+    }
+  }
+  return {
+    provider: provider.key,
+    status: results.some((item) => !item.ok) ? "Concluído com erros" : "Concluído",
+    results,
+  };
+}
+
+async function integrationHealth() {
+  const { Outbox, Inbox, Execution } = getIntegrationModels();
+  const providers = listIntegrationProviders();
+  return Promise.all(providers.map(async (provider) => {
+    const [queue, inbox, lastExecution] = await Promise.all([
+      Outbox.aggregate([
+        { $match: { provider: provider.key } },
+        { $group: { _id: "$status", count: { $sum: 1 }, oldest: { $min: "$createdAt" } } },
+      ]),
+      Inbox.aggregate([
+        { $match: { provider: provider.key } },
+        { $group: { _id: "$status", count: { $sum: 1 } } },
+      ]),
+      Execution.findOne({ provider: provider.key }).sort({ startedAt: -1 }).lean(),
+    ]);
+    return {
+      ...provider,
+      queue: Object.fromEntries(queue.map((item) => [item._id, item.count])),
+      inbox: Object.fromEntries(inbox.map((item) => [item._id, item.count])),
+      oldestPendingAt: queue
+        .filter((item) => ["Pendente", "Erro temporário", "Processando"].includes(item._id) && item.oldest)
+        .map((item) => new Date(item.oldest))
+        .sort((left, right) => left.getTime() - right.getTime())[0] || null,
+      lastExecution: lastExecution ? sanitizeIntegrationValue(lastExecution) : null,
+    };
+  }));
+}
+
+module.exports = { integrationHealth, synchronizeAll, synchronizeResource };

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

@@ -0,0 +1,89 @@
+"use strict";
+
+const { getIntegrationModels } = require("../models");
+const { sanitizeIntegrationError, sanitizeIntegrationValue } = require("../sanitizer");
+const { DEFAULT_ITEM_LIMIT, DEFAULT_TRACE_LIMIT } = require("./utils");
+
+async function runTrackedOperation({ provider, resource = "", operation = "execute", title, metadata = {}, runner }) {
+  const { Execution } = getIntegrationModels();
+  const startedAt = new Date();
+  const execution = await Execution.create({
+    provider,
+    resource,
+    operation,
+    title: title || `${provider}:${resource || operation}`,
+    status: "Executando",
+    startedAt,
+    metadata: sanitizeIntegrationValue(metadata),
+  });
+
+  const requests = [];
+  const errors = [];
+  const items = [];
+  let requestCount = 0;
+  let errorCount = 0;
+  let itemCount = 0;
+  const context = {
+    executionId: String(execution._id),
+    recordRequest(value) {
+      requestCount += 1;
+      if (requests.length < DEFAULT_TRACE_LIMIT) requests.push(sanitizeIntegrationValue(value));
+    },
+    recordError(value) {
+      errorCount += 1;
+      if (errors.length < DEFAULT_TRACE_LIMIT) errors.push(sanitizeIntegrationValue(value));
+    },
+    recordItem(value) {
+      itemCount += 1;
+      if (items.length < DEFAULT_ITEM_LIMIT) items.push(sanitizeIntegrationValue(value));
+    },
+    sanitize: sanitizeIntegrationValue,
+  };
+
+  try {
+    const result = await runner(context);
+    const summary = sanitizeIntegrationValue(result?.summary || result || {});
+    const status = errors.length ? "Concluído com erros" : "Concluído";
+    await Execution.updateOne({ _id: execution._id }, {
+      $set: {
+        status,
+        concludedAt: new Date(),
+        durationMs: Date.now() - startedAt.getTime(),
+        message: String(result?.message || ""),
+        summary,
+        requests,
+        requestCount,
+        requestsLimited: requestCount > requests.length,
+        errors,
+        errorCount,
+        errorsLimited: errorCount > errors.length,
+        items,
+        itemCount,
+        itemsLimited: itemCount > items.length,
+      },
+    });
+    return { executionId: String(execution._id), status, summary, result };
+  } catch (error) {
+    const sanitized = sanitizeIntegrationError(error);
+    await Execution.updateOne({ _id: execution._id }, {
+      $set: {
+        status: "Erro",
+        concludedAt: new Date(),
+        durationMs: Date.now() - startedAt.getTime(),
+        error: sanitized,
+        requests,
+        requestCount,
+        requestsLimited: requestCount > requests.length,
+        errors: [...errors, sanitized].slice(0, DEFAULT_TRACE_LIMIT),
+        errorCount: errorCount + 1,
+        errorsLimited: errorCount + 1 > DEFAULT_TRACE_LIMIT,
+        items,
+        itemCount,
+        itemsLimited: itemCount > items.length,
+      },
+    });
+    throw error;
+  }
+}
+
+module.exports = { runTrackedOperation };

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

@@ -0,0 +1,71 @@
+"use strict";
+
+const crypto = require("node:crypto");
+const os = require("node:os");
+
+const DEFAULT_LEASE_MS = 120_000;
+const DEFAULT_HEARTBEAT_MS = 30_000;
+const DEFAULT_ITEM_LIMIT = 100;
+const DEFAULT_TRACE_LIMIT = 100;
+
+function workerId(prefix = "integration") {
+  return `${prefix}:${os.hostname()}:${process.pid}`;
+}
+
+function stableStringify(value) {
+  if (value == null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+}
+
+function payloadHash(payload) {
+  return crypto.createHash("sha256").update(stableStringify(payload)).digest("hex");
+}
+
+function calculateBackoff(attempt, policy = {}) {
+  const strategy = policy.strategy || "exponential";
+  const initialMs = Math.max(1, Number(policy.initialMs || 60_000));
+  const maxMs = Math.max(initialMs, Number(policy.maxMs || 21_600_000));
+  let delay = strategy === "fixed"
+    ? initialMs
+    : Math.min(maxMs, initialMs * (2 ** Math.max(0, Number(attempt || 1) - 1)));
+  if (policy.jitter !== false) {
+    const factor = 0.75 + Math.random() * 0.5;
+    delay = Math.max(1, Math.round(delay * factor));
+  }
+  return delay;
+}
+
+function classifyError(provider, error, attempts) {
+  const custom = typeof provider.classifyError === "function"
+    ? provider.classifyError(error, { attempts })
+    : null;
+  const retryable = custom?.retryable ?? (
+    typeof provider.isRetryable === "function"
+      ? provider.isRetryable(error)
+      : error?.retryable !== false && Number(error?.statusCode || error?.response?.status || 500) >= 500
+  );
+  const maxAttempts = Math.max(1, Number(custom?.maxAttempts || provider.maxAttempts || 5));
+  return {
+    retryable: Boolean(retryable),
+    definitive: !retryable || attempts >= maxAttempts,
+    maxAttempts,
+    code: custom?.code || error?.code,
+  };
+}
+
+function isEnabled(provider) {
+  return typeof provider.enabled === "function" ? Boolean(provider.enabled()) : provider.enabled !== false;
+}
+
+module.exports = {
+  DEFAULT_HEARTBEAT_MS,
+  DEFAULT_ITEM_LIMIT,
+  DEFAULT_LEASE_MS,
+  DEFAULT_TRACE_LIMIT,
+  calculateBackoff,
+  classifyError,
+  isEnabled,
+  payloadHash,
+  workerId,
+};

package/src/modules/integrations/runtime.js

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = {
+  ...require("./runtime/inbox"),
+  ...require("./runtime/lease"),
+  ...require("./runtime/outbox"),
+  ...require("./runtime/sync"),
+  ...require("./runtime/tracking"),
+  ...require("./runtime/utils"),
+};

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 };

package/src/modules/omie/client.js

@@ -0,0 +1,252 @@
+"use strict";
+
+const axios = require("axios");
+const GenericError = require("../../core/errors/GenericError");
+const {
+  sanitizeIntegrationError,
+  sanitizeIntegrationValue,
+} = require("../integrations/sanitizer");
+
+const RETRYABLE_HTTP = new Set([408, 425, 429, 500, 502, 503, 504]);
+
+class OmieApiError extends GenericError {
+  constructor(message, options = {}) {
+    super(message, {
+      statusCode: options.statusCode || 502,
+      details: options.details,
+      cause: options.cause,
+    });
+    this.name = "OmieApiError";
+    this.code = options.code || "OMIE_API_ERROR";
+    this.retryable = options.retryable !== false;
+    this.response = options.response;
+    this.trace = options.trace;
+  }
+}
+
+function getPath(value, path, fallback) {
+  if (!path) return value ?? fallback;
+  const result = String(path).split(".").filter(Boolean).reduce(
+    (current, part) => (current == null ? undefined : current[part]),
+    value,
+  );
+  return result === undefined ? fallback : result;
+}
+
+function resolveTemplate(value, scope = {}) {
+  if (Array.isArray(value)) return value.map((item) => resolveTemplate(item, scope));
+  if (!value || typeof value !== "object") {
+    if (typeof value !== "string" || !value.startsWith("$")) return value;
+    const [root, ...parts] = value.slice(1).split(".");
+    return getPath(scope[root], parts.join("."));
+  }
+  if (Object.prototype.hasOwnProperty.call(value, "$value")) return value.$value;
+  if (Object.prototype.hasOwnProperty.call(value, "$path")) {
+    const [root, ...parts] = String(value.$path).replace(/^\$/, "").split(".");
+    return getPath(scope[root], parts.join("."), value.default);
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [key, resolveTemplate(item, scope)]),
+  );
+}
+
+function normalizeEndpoint(baseUrl, endpoint) {
+  const base = String(baseUrl || "").trim().replace(/\/+$/, "");
+  const value = String(endpoint || "").trim();
+  if (!base || !value) {
+    throw new OmieApiError("A chamada Omie exige baseUrl e endpoint declarados pela Central.", {
+      statusCode: 422,
+      retryable: false,
+      code: "OMIE_CALL_INVALID",
+    });
+  }
+  const absolute = /^https?:\/\//i.test(value) ? value : `${base}/${value.replace(/^\/+/, "")}`;
+  let parsed;
+  try {
+    parsed = new URL(absolute);
+  } catch (error) {
+    throw new OmieApiError("Endpoint Omie inválido.", {
+      statusCode: 422,
+      retryable: false,
+      code: "OMIE_ENDPOINT_INVALID",
+      cause: error,
+    });
+  }
+  if (!["https:", "http:"].includes(parsed.protocol)) {
+    throw new OmieApiError("Endpoint Omie deve usar HTTP ou HTTPS.", {
+      statusCode: 422,
+      retryable: false,
+      code: "OMIE_ENDPOINT_PROTOCOL",
+    });
+  }
+  return parsed.toString();
+}
+
+function responseError(body, statusCode) {
+  const code = body?.faultcode ?? body?.code ?? body?.codigo_status;
+  const description = body?.faultstring ?? body?.description ?? body?.descricao_status;
+  if (statusCode >= 200 && statusCode < 300 && !description) return null;
+  if (statusCode >= 200 && statusCode < 300 && String(code ?? "0") === "0") return null;
+  return new OmieApiError(description || `Omie retornou HTTP ${statusCode}.`, {
+    statusCode,
+    code: String(code || "OMIE_RESPONSE_ERROR"),
+    retryable: RETRYABLE_HTTP.has(Number(statusCode)),
+    response: sanitizeIntegrationValue(body),
+  });
+}
+
+function retryableTransportError(error) {
+  const statusCode = Number(error?.response?.status || error?.statusCode || 0);
+  return RETRYABLE_HTTP.has(statusCode)
+    || ["ECONNABORTED", "ECONNRESET", "ETIMEDOUT", "EAI_AGAIN"].includes(error?.code)
+    || error?.name === "AbortError";
+}
+
+function wait(ms) {
+  return ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+}
+
+function createOmieClient(options = {}) {
+  const credentials = options.credentials || {};
+  const appKey = String(credentials.appKey || "").trim();
+  const appSecret = String(credentials.appSecret || "").trim();
+  const baseUrl = String(credentials.baseUrl || options.baseUrl || "").trim();
+  const timeoutMs = Math.max(100, Number(options.timeoutMs || 30_000));
+  const maxAttempts = Math.max(1, Number(options.maxAttempts || 3));
+  const retryInitialMs = Math.max(0, Number(options.retryInitialMs ?? 500));
+  const transport = options.transport || (async ({ url, body, timeout }) => {
+    const response = await axios.post(url, body, {
+      timeout,
+      headers: { "content-type": "application/json", accept: "application/json" },
+      validateStatus: () => true,
+    });
+    return { status: response.status, data: response.data };
+  });
+
+  if (!appKey || !appSecret) {
+    throw new OmieApiError("Credenciais Omie não configuradas.", {
+      statusCode: 422,
+      retryable: false,
+      code: "OMIE_CREDENTIALS_MISSING",
+    });
+  }
+
+  async function execute(callDefinition, input = {}, context = {}) {
+    if (!callDefinition || typeof callDefinition !== "object") {
+      throw new OmieApiError("Definição de chamada Omie inválida.", {
+        statusCode: 422,
+        retryable: false,
+        code: "OMIE_CALL_INVALID",
+      });
+    }
+    const url = normalizeEndpoint(baseUrl, callDefinition.endpoint);
+    const call = String(callDefinition.call || "").trim();
+    if (!call) {
+      throw new OmieApiError("A Central deve declarar a operação/call Omie.", {
+        statusCode: 422,
+        retryable: false,
+        code: "OMIE_CALL_MISSING",
+      });
+    }
+    const resolvedParam = resolveTemplate(callDefinition.param ?? [{}], {
+      input,
+      context,
+      cursor: context.cursor,
+    });
+    const body = {
+      call,
+      app_key: appKey,
+      app_secret: appSecret,
+      param: Array.isArray(resolvedParam) ? resolvedParam : [resolvedParam],
+    };
+    let lastError;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      const startedAt = Date.now();
+      const trace = {
+        endpoint: callDefinition.endpoint,
+        call,
+        attempt,
+        request: sanitizeIntegrationValue({ call, param: body.param }),
+      };
+      try {
+        const response = await transport({
+          url,
+          body,
+          timeout: Number(callDefinition.timeoutMs || timeoutMs),
+          attempt,
+        });
+        const status = Number(response?.status || 200);
+        const data = response?.data ?? {};
+        trace.httpStatus = status;
+        trace.response = sanitizeIntegrationValue(data);
+        trace.durationMs = Date.now() - startedAt;
+        const normalized = responseError(data, status);
+        if (normalized) throw normalized;
+        trace.status = "success";
+        context.recordRequest?.(trace);
+        return { data, trace };
+      } catch (error) {
+        const normalized = error instanceof OmieApiError
+          ? error
+          : new OmieApiError(error?.message || "Falha ao chamar a API Omie.", {
+            statusCode: Number(error?.response?.status || 502),
+            retryable: retryableTransportError(error),
+            code: error?.code || "OMIE_TRANSPORT_ERROR",
+            response: sanitizeIntegrationValue(error?.response?.data || {}),
+            cause: error,
+          });
+        trace.status = "error";
+        trace.durationMs = Date.now() - startedAt;
+        trace.error = sanitizeIntegrationError(normalized);
+        context.recordRequest?.(trace);
+        normalized.trace = trace;
+        lastError = normalized;
+        if (!normalized.retryable || attempt >= maxAttempts) throw normalized;
+        const delay = Math.min(5_000, retryInitialMs * (2 ** (attempt - 1)));
+        await wait(delay);
+      }
+    }
+    throw lastError;
+  }
+
+  async function paginate(callDefinition, input = {}, context = {}) {
+    const pagination = callDefinition.pagination || {};
+    const items = [];
+    let page = Number(input.page || pagination.startPage || 1);
+    let totalPages = page;
+    let lastResponse = {};
+    do {
+      const pageInput = {
+        ...input,
+        page,
+        pageSize: Number(input.pageSize || pagination.pageSize || 100),
+      };
+      const result = await execute(callDefinition, pageInput, context);
+      lastResponse = result.data;
+      const pageItems = getPath(lastResponse, pagination.itemsPath, []);
+      if (!Array.isArray(pageItems)) {
+        throw new OmieApiError(`itemsPath inválido na chamada ${callDefinition.call}.`, {
+          statusCode: 422,
+          retryable: false,
+          code: "OMIE_ITEMS_PATH_INVALID",
+        });
+      }
+      items.push(...pageItems);
+      totalPages = Number(getPath(lastResponse, pagination.totalPagesPath, page)) || page;
+      page += 1;
+    } while (page <= totalPages && (!pagination.maxPages || page <= Number(pagination.maxPages)));
+    return { items, response: lastResponse, totalPages };
+  }
+
+  return { execute, paginate };
+}
+
+module.exports = {
+  OmieApiError,
+  createOmieClient,
+  getPath,
+  normalizeEndpoint,
+  resolveTemplate,
+  responseError,
+};