@oondemand/oon-core-back 0.5.6 → 0.6.1

package/src/modules/integrations/worker.js

@@ -1,56 +0,0 @@
-"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

@@ -1,282 +0,0 @@
-"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 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)
-    || ["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();
-}
-
-async function resolveCallParam(callDefinition, input = {}, context = {}) {
-  const declared = typeof callDefinition.param === "function"
-    ? await callDefinition.param({ input, context, cursor: context.cursor })
-    : callDefinition.param;
-  return resolveTemplate(declared ?? [{}], {
-    input,
-    context,
-    cursor: context.cursor,
-  });
-}
-
-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 = await resolveCallParam(callDefinition, input, context);
-    const body = {
-      call,
-      app_key: appKey,
-      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 <= callMaxAttempts; 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 ?? {};
-        const emptyResult = isConfiguredEmptyResult(callDefinition, data);
-        trace.httpStatus = status;
-        trace.response = sanitizeIntegrationValue(data);
-        trace.durationMs = Date.now() - startedAt;
-        trace.emptyResult = emptyResult;
-        if (!emptyResult) {
-          const normalized = responseError(data, status);
-          if (normalized) throw normalized;
-        }
-        trace.status = "success";
-        context.recordRequest?.(trace);
-        return { data, trace, emptyResult };
-      } 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 >= callMaxAttempts) 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,
-  isConfiguredEmptyResult,
-  normalizeEndpoint,
-  resolveCallParam,
-  resolveTemplate,
-  responseError,
-};

package/src/modules/omie/definitions.js

@@ -1,212 +0,0 @@
-"use strict";
-
-const registry = require("../../core/registry");
-const GenericError = require("../../core/errors/GenericError");
-const { normalizeKey } = require("../integrations/registry");
-
-const LIST_MODES = new Set(["import", "full", "incremental", "individual"]);
-const DIRECTIONS = new Set(["inbound", "outbound", "bidirectional"]);
-const CONFLICT_POLICIES = new Set(["remote-wins", "local-wins", "skip", "error"]);
-
-function cloneDeclarative(value) {
-  if (Array.isArray(value)) return value.map(cloneDeclarative);
-  if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneDeclarative(item)]));
-}
-
-function normalizeCall(key, definition = {}) {
-  const callKey = normalizeKey(key, "identificador da chamada Omie");
-  if (!definition.endpoint || !definition.call) {
-    throw new GenericError(
-      `A chamada Omie ${callKey} deve declarar endpoint e call.`,
-      { statusCode: 422 },
-    );
-  }
-  return {
-    ...cloneDeclarative(definition),
-    key: callKey,
-    label: String(definition.label || callKey),
-    connectionTest: definition.connectionTest === true,
-  };
-}
-
-function normalizeList(definition = {}, index = 0) {
-  const key = normalizeKey(definition.key, `identificador da lista Omie ${index + 1}`);
-  const mode = String(definition.mode || "full").toLowerCase();
-  const direction = String(definition.direction || "inbound").toLowerCase();
-  const conflict = String(definition.policies?.conflict || "remote-wins").toLowerCase();
-  if (!LIST_MODES.has(mode)) {
-    throw new GenericError(`Modo inválido na lista Omie ${key}: ${mode}.`, { statusCode: 422 });
-  }
-  if (!DIRECTIONS.has(direction)) {
-    throw new GenericError(`Direção inválida na lista Omie ${key}: ${direction}.`, { statusCode: 422 });
-  }
-  if (!CONFLICT_POLICIES.has(conflict)) {
-    throw new GenericError(`Política de conflito inválida na lista Omie ${key}: ${conflict}.`, {
-      statusCode: 422,
-    });
-  }
-  if (definition.filter !== undefined && typeof definition.filter !== "function") {
-    throw new GenericError(`O filtro da lista Omie ${key} deve ser uma função.`, {
-      statusCode: 422,
-    });
-  }
-  if (!definition.call) {
-    throw new GenericError(`A lista Omie ${key} deve referenciar uma chamada declarada.`, {
-      statusCode: 422,
-    });
-  }
-  if (!definition.target?.model || !definition.target?.externalKey) {
-    throw new GenericError(
-      `A lista Omie ${key} deve declarar target.model e target.externalKey.`,
-      { statusCode: 422 },
-    );
-  }
-  return {
-    ...cloneDeclarative(definition),
-    key,
-    label: String(definition.label || key),
-    description: String(definition.description || ""),
-    call: normalizeKey(definition.call, `chamada da lista ${key}`),
-    mode,
-    direction,
-    order: Number(definition.order ?? (index + 1) * 10),
-    includeInFullSync: definition.includeInFullSync !== false,
-    policies: {
-      create: definition.policies?.create !== false,
-      update: definition.policies?.update !== false,
-      inactivate: definition.policies?.inactivate === true,
-      conflict,
-      ...(definition.policies || {}),
-    },
-  };
-}
-
-function normalizeWebhook(definition = {}, index = 0) {
-  const eventType = String(definition.eventType || "*").trim();
-  if (!eventType) {
-    throw new GenericError(`Webhook Omie ${index + 1} sem eventType.`, { statusCode: 422 });
-  }
-  const actions = Array.isArray(definition.actions) ? definition.actions : [];
-  actions.forEach((action, actionIndex) => {
-    if (!action?.handler) {
-      throw new GenericError(
-        `A ação ${actionIndex + 1} do webhook ${eventType} deve declarar handler.`,
-        { statusCode: 422 },
-      );
-    }
-  });
-  return {
-    ...cloneDeclarative(definition),
-    eventType,
-    resource: String(definition.resource || ""),
-    actions,
-  };
-}
-
-function collectOmieDefinitions() {
-  const result = {
-    calls: {},
-    lists: [],
-    webhooks: [],
-    handlers: {},
-    instances: [],
-    legacy: {},
-  };
-  for (const declaration of registry.listOmieMappings()) {
-    if (typeof declaration.toOmie === "function") {
-      const legacyKey = normalizeKey(declaration.name, "mapping Omie legado");
-      result.legacy[legacyKey] = {
-        key: legacyKey,
-        label: String(declaration.label || declaration.name || legacyKey),
-        toOmie: declaration.toOmie,
-      };
-    }
-    for (const [key, call] of Object.entries(declaration.calls || {})) {
-      const normalized = normalizeCall(key, call);
-      if (result.calls[normalized.key]) {
-        throw new GenericError(`Chamada Omie duplicada: ${normalized.key}.`, { statusCode: 422 });
-      }
-      result.calls[normalized.key] = normalized;
-    }
-    for (const list of declaration.lists || []) result.lists.push(normalizeList(list, result.lists.length));
-    for (const webhook of declaration.webhooks || []) {
-      result.webhooks.push(normalizeWebhook(webhook, result.webhooks.length));
-    }
-    for (const [handler, implementation] of Object.entries(declaration.handlers || {})) {
-      if (typeof implementation !== "function") {
-        throw new GenericError(`Handler Omie ${handler} deve ser uma função.`, { statusCode: 422 });
-      }
-      if (result.handlers[handler]) {
-        throw new GenericError(`Handler Omie duplicado: ${handler}.`, { statusCode: 422 });
-      }
-      result.handlers[handler] = implementation;
-    }
-    for (const instance of declaration.instances || []) {
-      result.instances.push({
-        id: normalizeKey(instance.id || instance.instanceId || "default", "instância Omie"),
-        label: String(instance.label || instance.id || "Omie"),
-      });
-    }
-  }
-
-  const listKeys = new Set();
-  for (const list of result.lists) {
-    if (listKeys.has(list.key)) {
-      throw new GenericError(`Lista Omie duplicada: ${list.key}.`, { statusCode: 422 });
-    }
-    listKeys.add(list.key);
-    if (!result.calls[list.call]) {
-      throw new GenericError(
-        `A lista Omie ${list.key} referencia a chamada inexistente ${list.call}.`,
-        { statusCode: 422 },
-      );
-    }
-  }
-  return result;
-}
-
-function describeOmieDefinitions(definitions = collectOmieDefinitions()) {
-  return {
-    calls: Object.values(definitions.calls).map((call) => ({
-      key: call.key,
-      label: call.label,
-      endpoint: call.endpoint,
-      call: call.call,
-      paginated: Boolean(call.pagination),
-      connectionTest: call.connectionTest,
-    })),
-    lists: definitions.lists.map((list) => ({
-      key: list.key,
-      label: list.label,
-      description: list.description,
-      call: list.call,
-      mode: list.mode,
-      direction: list.direction,
-      targetModel: list.target.model,
-      externalKey: list.target.externalKey,
-      filtered: typeof list.filter === "function",
-      policies: list.policies,
-      schedule: list.schedule || null,
-      order: list.order,
-    })),
-    webhooks: definitions.webhooks.map((webhook) => ({
-      eventType: webhook.eventType,
-      resource: webhook.resource,
-      actions: webhook.actions.map((action) => ({ handler: action.handler })),
-    })),
-    instances: definitions.instances,
-    legacyMappings: Object.values(definitions.legacy || {}).map((mapping) => ({
-      key: mapping.key,
-      label: mapping.label,
-    })),
-  };
-}
-
-module.exports = {
-  collectOmieDefinitions,
-  describeOmieDefinitions,
-  normalizeCall,
-  normalizeList,
-  normalizeWebhook,
-};

package/src/modules/omie/index.js

@@ -1,33 +0,0 @@
-"use strict";
-
-const client = require("./client");
-const definitions = require("./definitions");
-const models = require("./models");
-const provider = require("./provider");
-
-const omie = {
-  sync(input = {}) {
-    return provider.enqueueOmieCall(input);
-  },
-  enqueue(input = {}) {
-    return provider.enqueueOmieCall(input);
-  },
-  async call(input = {}, options = {}) {
-    const declaredCall = input.callKey || input.mapping || input.name;
-    const normalized = definitions.collectOmieDefinitions();
-    return provider.executeConfiguredCall(
-      normalized,
-      declaredCall,
-      input.payload || input.input || {},
-      { ...options, instanceId: input.instanceId || options.instanceId },
-    );
-  },
-};
-
-module.exports = {
-  ...client,
-  ...definitions,
-  ...models,
-  ...provider,
-  omie,
-};