@oondemand/oon-core-back 0.3.57 → 0.3.58

package/package.json

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

package/src/boot/database.js

@@ -3,6 +3,7 @@ const registry = require("../core/registry");
 const ctx = require("../core/context");
 const { getIntegrationModels } = require("../modules/integrations/models");
 const { listIntegrationProviders } = require("../modules/integrations/registry");
+const { getOmieModels, omieEnabled } = require("../modules/omie");
 
 function buildMongoUri() {
   const cfg = {
@@ -72,16 +73,19 @@ async function syncDeclaredIndexes(entries = registry.listModels()) {
   return results;
 }
 
-async function syncIntegrationIndexes() {
-  const enabled = Boolean(
+async function syncTechnicalIndexes() {
+  const integrationsEnabled = Boolean(
     ctx.config.appManifest?.modules?.integrations
     || ctx.config.modules?.integrations
     || listIntegrationProviders().length,
   );
-  if (!enabled || !shouldSyncDeclaredIndexes()) return [];
+  if (!shouldSyncDeclaredIndexes() || !integrationsEnabled) return [];
+
+  const models = Object.values(getIntegrationModels());
+  if (omieEnabled(ctx.config)) models.push(...Object.values(getOmieModels()));
 
   const results = [];
-  for (const model of Object.values(getIntegrationModels())) {
+  for (const model of models) {
     const dropped = await model.syncIndexes();
     const normalized = Array.isArray(dropped) ? dropped : [];
     results.push({ model: model.modelName, dropped: normalized });
@@ -92,11 +96,15 @@ async function syncIntegrationIndexes() {
   return results;
 }
 
+async function syncIntegrationIndexes() {
+  return syncTechnicalIndexes();
+}
+
 async function connectDB() {
   const uri = buildMongoUri();
   await mongoose.connect(uri, connectionOptions());
   await syncDeclaredIndexes();
-  await syncIntegrationIndexes();
+  await syncTechnicalIndexes();
   console.log(`Conectado ao MongoDB (${databaseLabel(uri)})`);
   return mongoose.connection;
 }
@@ -109,4 +117,5 @@ module.exports = {
   shouldSyncDeclaredIndexes,
   syncDeclaredIndexes,
   syncIntegrationIndexes,
+  syncTechnicalIndexes,
 };

package/src/boot/loadCentral.js

@@ -15,6 +15,7 @@ const {
   PROCESS_MANIFEST_FILENAME,
   loadProcessManifest,
 } = require("../manifest/processManifest");
+const { ensureOmieProviderRegistered } = require("../modules/omie");
 
 const DOMAIN_DIRS = [
   "models",
@@ -91,6 +92,9 @@ function loadCentral(cwd = process.cwd()) {
     if (fs.existsSync(full)) requireDir(full);
   }
 
+  // O adaptador nativo é montado depois das declarações da Central. Assim,
+  // endpoints, mappings, listas e ações permanecem fora do pacote técnico.
+  ensureOmieProviderRegistered(ctx.config);
   return ctx.config;
 }
 
@@ -107,4 +111,4 @@ module.exports = {
   DOMAIN_DIRS,
   APP_CONFIG_KEYS,
   assertConfigBoundary,
-};
+};

package/src/index.js

@@ -7,7 +7,7 @@ const define = require("./core/define");
 const fields = require("./core/fields");
 const registry = require("./core/registry");
 const GenericError = require("./core/errors/GenericError");
-const { omie } = require("./modules/omie");
+const omieModule = require("./modules/omie");
 const integrations = require("./modules/integrations");
 const appManifest = require("./manifest/appManifest");
 const domainManifest = require("./manifest/domainManifest");
@@ -71,7 +71,17 @@ module.exports = {
   drainProcessJobs: processRuntime.drainProcessJobs,
 
   fields,
-  omie,
+  omie: omieModule.omie,
+  omieModule,
+  createOmieClient: omieModule.createOmieClient,
+  OmieApiError: omieModule.OmieApiError,
+  enqueueOmieCall: omieModule.enqueueOmieCall,
+  ensureOmieProviderRegistered: omieModule.ensureOmieProviderRegistered,
+  collectOmieDefinitions: omieModule.collectOmieDefinitions,
+  describeOmieDefinitions: omieModule.describeOmieDefinitions,
+  saveOmieConfiguration: omieModule.saveOmieConfiguration,
+  listOmieConfigurations: omieModule.listOmieConfigurations,
+  testOmieConnection: omieModule.testOmieConnection,
   integrations,
   registerIntegrationProvider: integrations.registerIntegrationProvider,
   enqueueIntegration: integrations.enqueueIntegration,

package/src/modules/integrations/models.js

@@ -59,6 +59,7 @@ function inboxSchema() {
     deduplicationKey: { type: String, required: true, unique: true },
     payloadHash: { type: String, required: true, index: true },
     payload: jsonField({}),
+    metadata: jsonField({}),
     receivedAt: { type: Date, default: Date.now, index: true },
     status: { type: String, enum: INBOX_STATUSES, default: "Pendente", index: true },
     attempts: { type: Number, min: 0, default: 0 },

package/src/modules/integrations/registry.js

@@ -34,6 +34,22 @@ function normalizeResources(resources = []) {
   });
 }
 
+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,
@@ -45,6 +61,7 @@ function metadataFor(provider) {
       ? (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,

package/src/modules/integrations/routes.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const express = require("express");
+const GenericError = require("../../core/errors/GenericError");
 const auth = require("../../core/middlewares/auth");
 const { rbac } = require("../../core/middlewares/rbac");
 const { asyncHandler } = require("../../core/utils/helpers");
@@ -32,6 +33,15 @@ function pagination(query = {}) {
   return { limit, page, skip: (page - 1) * limit };
 }
 
+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();
 
@@ -57,6 +67,44 @@ function buildIntegrationRouter() {
     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/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() });
   }));

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

@@ -10,18 +10,24 @@ const { DEFAULT_LEASE_MS, calculateBackoff, classifyError, isEnabled, payloadHas
 
 async function receiveWebhook(input) {
   const provider = getIntegrationProvider(input.provider);
+  let verificationMetadata = {};
   if (typeof provider.verifyWebhook === "function") {
-    const accepted = await provider.verifyWebhook({
+    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 sanitizedPayload = sanitizeIntegrationValue(input.payload || {});
+  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(input.externalEventId || "").trim();
+  const externalEventId = String(normalized.externalEventId || "").trim();
   const deduplicationKey = `${provider.key}:${externalEventId || hash}`;
   const { Inbox } = getIntegrationModels();
   return Inbox.findOneAndUpdate(
@@ -29,12 +35,16 @@ async function receiveWebhook(input) {
     {
       $setOnInsert: {
         provider: provider.key,
-        resource: String(input.resource || ""),
-        eventType: String(input.eventType || "unknown"),
+        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,
@@ -76,6 +86,7 @@ async function processWebhookInbox(options = {}) {
           source: "inbox",
           inboxId: String(event._id),
           externalEventId: event.externalEventId || "",
+          ...sanitizeIntegrationValue(event.metadata || {}),
         },
         runner: (trace) => handler(event, {
           ...options,

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