@oondemand/oon-core-back 0.5.6 → 0.6.0

package/src/modules/omie/provider.js

@@ -1,529 +0,0 @@
-"use strict";
-
-const coreRegistry = require("../../core/registry");
-const GenericError = require("../../core/errors/GenericError");
-const { registerIntegrationProvider } = require("../integrations/registry");
-const { enqueueIntegration, runTrackedOperation } = require("../integrations/runtime");
-const { sanitizeIntegrationError, sanitizeIntegrationValue } = require("../integrations/sanitizer");
-const { createOmieClient, getPath, resolveTemplate, OmieApiError } = require("./client");
-const { collectOmieDefinitions, describeOmieDefinitions } = require("./definitions");
-const {
-  ensureOmieWebhookAccess,
-  getOmieModels,
-  listOmieConfigurations,
-  normalizeInstanceId,
-  resolveInstanceByWebhookToken,
-  resolveOmieConfiguration,
-  rotateOmieWebhookToken,
-  saveOmieConfiguration,
-  updateConnectionStatus,
-} = require("./models");
-
-function mapRecord(item, mapping = {}, scope = {}) {
-  if (typeof mapping === "function") return mapping(item, scope);
-  return Object.fromEntries(Object.entries(mapping).map(([field, source]) => {
-    if (typeof source === "string" && !source.startsWith("$")) {
-      return [field, getPath(item, source)];
-    }
-    return [field, resolveTemplate(source, { ...scope, item })];
-  }));
-}
-
-function assertModel(list) {
-  const entry = coreRegistry.getModel(list.target.model);
-  if (!entry?.mongooseModel) {
-    throw new GenericError(
-      `A lista Omie ${list.key} referencia a model não registrada ${list.target.model}.`,
-      { statusCode: 422 },
-    );
-  }
-  return entry.mongooseModel;
-}
-
-async function clientFor(instanceId, options = {}) {
-  const configuration = await resolveOmieConfiguration(instanceId, { includeSecrets: true });
-  if (!configuration.active) {
-    throw new GenericError(`A instância Omie ${configuration.label} está desativada.`, {
-      statusCode: 503,
-    });
-  }
-  return {
-    configuration,
-    client: createOmieClient({
-      credentials: {
-        appKey: configuration.appKey,
-        appSecret: configuration.appSecret,
-        baseUrl: configuration.baseUrl,
-      },
-      timeoutMs: options.timeoutMs,
-      maxAttempts: options.maxAttempts,
-      retryInitialMs: options.retryInitialMs,
-      transport: options.transport,
-    }),
-  };
-}
-
-async function executeConfiguredCall(definitions, callKey, input = {}, options = {}) {
-  const key = String(callKey || "").trim().toLowerCase();
-  let definition = definitions.calls[key];
-  if (!definition && definitions.legacy?.[key]) {
-    const request = await definitions.legacy[key].toOmie(input);
-    if (!request?.endpoint || !request?.call) {
-      throw new GenericError(
-        `O mapping Omie legado ${key} deve retornar endpoint e call.`,
-        { statusCode: 422 },
-      );
-    }
-    definition = { ...request, key, label: definitions.legacy[key].label };
-  }
-  if (!definition) {
-    throw new GenericError(`Chamada Omie não declarada pela Central: ${key || "não informada"}.`, {
-      statusCode: 404,
-    });
-  }
-  const instanceId = normalizeInstanceId(options.instanceId || input.instanceId || "default");
-  const { client, configuration } = await clientFor(instanceId, options);
-  const context = {
-    ...(options.context || {}),
-    instanceId,
-    cursor: options.cursor,
-  };
-  const result = definition.pagination && options.paginate !== false
-    ? await client.paginate(definition, input, context)
-    : await client.execute(definition, input, context);
-  return {
-    instanceId,
-    call: key,
-    configuration: {
-      instanceId: configuration.instanceId,
-      label: configuration.label,
-      environment: configuration.environment,
-    },
-    ...result,
-  };
-}
-
-function effectiveListMode(list, payload = {}) {
-  const requested = String(payload.mode || "").toLowerCase();
-  return requested || list.mode;
-}
-
-async function evaluateListFilter(item, filter, scope = {}) {
-  if (typeof filter !== "function") return { include: true, reason: "" };
-  const result = await filter(item, scope);
-  if (result && typeof result === "object" && Object.prototype.hasOwnProperty.call(result, "include")) {
-    return {
-      include: result.include !== false,
-      reason: String(result.reason || "filtered"),
-    };
-  }
-  return {
-    include: result !== false,
-    reason: result === false ? "filtered" : "",
-  };
-}
-
-async function synchronizeOmieList(definitions, list, event, context = {}) {
-  const mode = effectiveListMode(list, event.payload || {});
-  if (!["import", "full", "incremental", "individual"].includes(mode)) {
-    throw new GenericError(`Modo de execução inválido para ${list.label}: ${mode}.`, {
-      statusCode: 422,
-    });
-  }
-  if (!list.direction || list.direction === "outbound") {
-    throw new GenericError(`A lista ${list.label} não permite sincronização de entrada.`, {
-      statusCode: 422,
-    });
-  }
-
-  const Model = assertModel(list);
-  const instanceId = normalizeInstanceId(event.payload?.instanceId || "default");
-  const { ListState } = getOmieModels();
-  const stateQuery = { provider: "omie", instanceId, listKey: list.key };
-  const state = await ListState.findOneAndUpdate(
-    stateQuery,
-    { $set: { status: "running", lastStartedAt: new Date(), diagnostic: {} } },
-    { upsert: true, new: true, setDefaultsOnInsert: true },
-  ).lean();
-
-  const input = {
-    ...(event.payload || {}),
-    instanceId,
-    pageSize: Number(
-      event.payload?.pageSize
-      || list.batchSize
-      || definitions.calls[list.call]?.pagination?.pageSize
-      || 100,
-    ),
-    cursor: mode === "incremental" ? state.cursor : undefined,
-  };
-  const callResult = await executeConfiguredCall(definitions, list.call, input, {
-    instanceId,
-    cursor: input.cursor,
-    paginate: mode !== "individual",
-    context,
-    transport: context.transport,
-    timeoutMs: context.timeoutMs,
-    maxAttempts: context.maxAttempts,
-    retryInitialMs: context.retryInitialMs,
-  });
-  const callDefinition = definitions.calls[list.call];
-  const items = Array.isArray(callResult.items)
-    ? callResult.items
-    : getPath(callResult.data, list.itemsPath || callDefinition.itemsPath || callDefinition.pagination?.itemsPath, []);
-  if (!Array.isArray(items)) {
-    throw new GenericError(`A chamada ${list.call} não retornou uma lista para ${list.label}.`, {
-      statusCode: 422,
-    });
-  }
-
-  const summary = {
-    mode,
-    received: items.length,
-    created: 0,
-    updated: 0,
-    skipped: 0,
-    inactivated: 0,
-    errors: 0,
-  };
-  const seen = [];
-  const failures = [];
-
-  for (const [index, item] of items.entries()) {
-    let externalValue;
-    try {
-      const scope = {
-        input,
-        response: callResult.response || callResult.data,
-        instanceId,
-        index,
-      };
-      const filterResult = await evaluateListFilter(item, list.filter, scope);
-      if (!filterResult.include) {
-        summary.skipped += 1;
-        context.recordItem?.({
-          index,
-          status: "skipped",
-          reason: filterResult.reason || "filtered",
-        });
-        continue;
-      }
-      const mapped = mapRecord(item, list.mapping || {}, scope);
-      const externalField = list.target.externalKey;
-      externalValue = mapped[externalField]
-        ?? getPath(item, list.sourceExternalKey || externalField);
-      if (externalValue === undefined || externalValue === null || externalValue === "") {
-        throw new GenericError(`Item sem chave externa ${externalField}.`, { statusCode: 422 });
-      }
-      mapped[externalField] = externalValue;
-      seen.push(externalValue);
-      const current = await Model.findOne({ [externalField]: externalValue }).lean();
-      if (current && list.policies.conflict === "skip") {
-        summary.skipped += 1;
-        continue;
-      }
-      if (current && list.policies.conflict === "local-wins") {
-        const remoteDate = getPath(item, list.remoteUpdatedAtPath);
-        if (!remoteDate || new Date(current.updatedAt || 0) > new Date(remoteDate)) {
-          summary.skipped += 1;
-          continue;
-        }
-      }
-      if (current && list.policies.conflict === "error") {
-        throw new GenericError(`Conflito com registro local ${externalValue}.`, { statusCode: 409 });
-      }
-      if (!current && !list.policies.create) {
-        summary.skipped += 1;
-        continue;
-      }
-      if (current && !list.policies.update) {
-        summary.skipped += 1;
-        continue;
-      }
-      await Model.findOneAndUpdate(
-        { [externalField]: externalValue },
-        { $set: mapped },
-        {
-          upsert: !current,
-          new: true,
-          runValidators: true,
-          setDefaultsOnInsert: true,
-          context: { integrationOrigin: { provider: "omie", instanceId, list: list.key } },
-        },
-      );
-      if (current) summary.updated += 1;
-      else summary.created += 1;
-      context.recordItem?.({ index, externalKey: externalValue, status: current ? "updated" : "created" });
-    } catch (error) {
-      summary.errors += 1;
-      const failure = {
-        index,
-        ...(externalValue !== undefined && externalValue !== null && externalValue !== ""
-          ? { externalKey: sanitizeIntegrationValue(externalValue) }
-          : {}),
-        error: sanitizeIntegrationError(error),
-      };
-      failures.push(failure);
-      context.recordItem?.(failure);
-      context.recordError?.(failure);
-    }
-  }
-
-  if (mode === "full" && list.policies.inactivate) {
-    const activeField = list.target.activeField || "active";
-    const inactiveValue = list.target.inactiveValue ?? false;
-    const result = await Model.updateMany(
-      { [list.target.externalKey]: { $nin: seen } },
-      { $set: { [activeField]: inactiveValue } },
-      { runValidators: true },
-    );
-    summary.inactivated = Number(result.modifiedCount || 0);
-  }
-
-  const cursorPath = list.cursorPath || callDefinition.cursorPath || callDefinition.pagination?.cursorPath;
-  const nextCursor = cursorPath
-    ? getPath(callResult.response || callResult.data, cursorPath, state.cursor)
-    : state.cursor;
-  await ListState.updateOne(stateQuery, {
-    $set: {
-      status: summary.errors ? "completed-with-errors" : "completed",
-      cursor: nextCursor,
-      lastCompletedAt: new Date(),
-      summary: sanitizeIntegrationValue(summary),
-      diagnostic: sanitizeIntegrationValue({ failures }),
-    },
-  });
-  return { ...summary, failures };
-}
-
-async function testOmieConnection(definitions, instanceId = "default", options = {}) {
-  const call = Object.values(definitions.calls).find((definition) => definition.connectionTest);
-  if (!call) {
-    throw new GenericError(
-      "A Central deve marcar uma chamada Omie com connectionTest: true.",
-      { statusCode: 422 },
-    );
-  }
-  try {
-    const result = await executeConfiguredCall(definitions, call.key, options.input || {}, {
-      ...options,
-      instanceId,
-      paginate: false,
-    });
-    await updateConnectionStatus(instanceId, { ok: true });
-    return {
-      ok: true,
-      instanceId: normalizeInstanceId(instanceId),
-      call: call.key,
-      diagnostic: sanitizeIntegrationValue({
-        httpStatus: result.trace?.httpStatus,
-        durationMs: result.trace?.durationMs,
-      }),
-    };
-  } catch (error) {
-    await updateConnectionStatus(instanceId, { ok: false, error: error?.message });
-    throw error;
-  }
-}
-
-async function handleOmieWebhook(definitions, event, context = {}) {
-  const mapping = definitions.webhooks.find((candidate) => candidate.eventType === event.eventType)
-    || definitions.webhooks.find((candidate) => candidate.eventType === "*");
-  if (!mapping) {
-    context.recordItem?.({
-      status: "ignored",
-      reason: "mapping-not-found",
-      eventType: event.eventType,
-    });
-    return { ignored: true, reason: "mapping-not-found", eventType: event.eventType };
-  }
-  const instanceId = normalizeInstanceId(event.metadata?.instanceId || "default");
-  const actions = [];
-  for (const [index, action] of mapping.actions.entries()) {
-    const payload = resolveTemplate(action.payload || { $path: "$payload" }, {
-      payload: event.payload,
-      event,
-      metadata: event.metadata || {},
-      instanceId,
-    });
-    const aggregateId = action.aggregateIdPath
-      ? getPath(event.payload, action.aggregateIdPath, "")
-      : String(action.aggregateId || "");
-    const ticket = await enqueueIntegration({
-      provider: "omie",
-      handler: action.handler,
-      resource: mapping.resource || event.resource || "",
-      operation: "webhook-action",
-      aggregateType: action.aggregateType || "",
-      aggregateId,
-      idempotencyKey: `omie:webhook:${event.deduplicationKey}:${index}:${action.handler}`,
-      payload: sanitizeIntegrationValue({
-        ...payload,
-        instanceId,
-        __oonIntegrationOrigin: {
-          provider: "omie",
-          kind: "webhook",
-          eventId: String(event._id),
-        },
-      }),
-    });
-    actions.push({ handler: action.handler, ticketId: String(ticket._id) });
-  }
-  return { ignored: false, mapping: mapping.eventType, actions };
-}
-
-function shouldPreventLoop(input = {}) {
-  return input.__oonIntegrationOrigin?.provider === "omie";
-}
-
-async function enqueueOmieCall(input = {}) {
-  if (shouldPreventLoop(input.payload || input)) {
-    return { skipped: true, reason: "bidirectional-loop-prevented" };
-  }
-  const call = String(input.call || input.mapping || "").trim().toLowerCase();
-  if (!call) throw new GenericError("Informe a chamada Omie declarada pela Central.", { statusCode: 422 });
-  const instanceId = normalizeInstanceId(input.instanceId || "default");
-  return enqueueIntegration({
-    provider: "omie",
-    handler: "OMIE_CALL_EXECUTE",
-    resource: String(input.resource || call),
-    operation: String(input.operation || "call"),
-    aggregateType: String(input.aggregateType || ""),
-    aggregateId: String(input.aggregateId || ""),
-    idempotencyKey: String(
-      input.idempotencyKey
-      || `omie:${instanceId}:${call}:${input.aggregateType || "call"}:${input.aggregateId || Date.now()}`,
-    ),
-    payload: sanitizeIntegrationValue({
-      instanceId,
-      call,
-      input: input.payload || input.input || {},
-    }),
-  });
-}
-
-function omieEnabled(config = {}) {
-  return Boolean(
-    config.appManifest?.modules?.omie
-    || config.modules?.omie
-    || coreRegistry.listOmieMappings().length,
-  );
-}
-
-function ensureOmieProviderRegistered(config = {}) {
-  if (!omieEnabled(config)) return null;
-  const definitions = collectOmieDefinitions();
-  const resources = definitions.lists.map((list) => ({
-    key: list.key,
-    label: list.label,
-    description: list.description,
-    syncHandler: "OMIE_LIST_SYNC",
-    includeInFullSync: list.includeInFullSync,
-    order: list.order,
-    operations: ["sync", list.mode, list.direction],
-  }));
-  const handlers = {
-    OMIE_CALL_EXECUTE: async (event, context) => {
-      const call = event.payload?.call;
-      return executeConfiguredCall(definitions, call, event.payload?.input || {}, {
-        instanceId: event.payload?.instanceId,
-        context,
-      });
-    },
-    OMIE_LIST_SYNC: async (event, context) => {
-      const list = definitions.lists.find((candidate) => candidate.key === event.resource);
-      if (!list) throw new GenericError(`Lista Omie não declarada: ${event.resource}.`, { statusCode: 404 });
-      return synchronizeOmieList(definitions, list, event, context);
-    },
-    ...definitions.handlers,
-  };
-
-  return registerIntegrationProvider({
-    key: "omie",
-    replace: true,
-    label: "Omie",
-    description: "Infraestrutura Omie nativa; chamadas, listas, mappings e ações são declarados pela Central.",
-    enabled: true,
-    capabilities: ["connection-test", "declarative-calls", "listas-omie", "webhooks"],
-    maxAttempts: 5,
-    retryPolicy: { strategy: "exponential", initialMs: 60_000, maxMs: 21_600_000, jitter: true },
-    classifyError(error) {
-      return {
-        retryable: error instanceof OmieApiError ? error.retryable : error?.retryable !== false,
-        code: error?.code,
-      };
-    },
-    resources,
-    handlers,
-    webhooks: {
-      "*": (event, context) => handleOmieWebhook(definitions, event, context),
-    },
-    async verifyWebhook({ token }) {
-      const instanceId = await resolveInstanceByWebhookToken(token);
-      return instanceId ? { accepted: true, metadata: { instanceId } } : false;
-    },
-    configuration: {
-      enabled: true,
-      multiInstance: true,
-      fields: [
-        { key: "instanceId", label: "Instância", readOnly: true },
-        { key: "label", label: "Nome" },
-        { key: "active", label: "Ativa", type: "boolean" },
-        { key: "environment", label: "Ambiente", type: "select", options: ["production", "homologation"] },
-        { key: "baseUrl", label: "URL base" },
-        { key: "appKey", label: "App Key", type: "password", writeOnly: true },
-        { key: "appSecret", label: "App Secret", type: "password", writeOnly: true },
-        { key: "webhookToken", label: "Token do webhook", type: "password", writeOnly: true },
-      ],
-    },
-    getConfiguration: listOmieConfigurations,
-    saveConfiguration: saveOmieConfiguration,
-    testConnection: (instanceId, options) => testOmieConnection(definitions, instanceId, options),
-    getWebhookAccess: (instanceId) => ensureOmieWebhookAccess(instanceId),
-    rotateWebhookToken: (instanceId) => rotateOmieWebhookToken(instanceId),
-    executeCall: (callKey, input, options) => runTrackedOperation({
-      provider: "omie",
-      resource: callKey,
-      operation: "call",
-      title: `Omie: ${callKey}`,
-      metadata: { source: options?.source || "api", instanceId: options?.instanceId || "default" },
-      runner: (context) => executeConfiguredCall(definitions, callKey, input, { ...options, context }),
-    }),
-    describe: async () => {
-      const descriptor = describeOmieDefinitions(definitions);
-      const { ListState } = getOmieModels();
-      const states = await ListState.find({ provider: "omie" }).lean();
-      return {
-        ...descriptor,
-        lists: descriptor.lists.map((list) => ({
-          ...list,
-          executions: states
-            .filter((state) => state.listKey === list.key)
-            .map((state) => sanitizeIntegrationValue({
-              instanceId: state.instanceId,
-              status: state.status,
-              cursor: state.cursor,
-              lastStartedAt: state.lastStartedAt,
-              lastCompletedAt: state.lastCompletedAt,
-              summary: state.summary,
-              diagnostic: state.diagnostic,
-            })),
-        })),
-      };
-    },
-  });
-}
-
-module.exports = {
-  clientFor,
-  enqueueOmieCall,
-  ensureOmieProviderRegistered,
-  evaluateListFilter,
-  executeConfiguredCall,
-  handleOmieWebhook,
-  mapRecord,
-  omieEnabled,
-  shouldPreventLoop,
-  synchronizeOmieList,
-  testOmieConnection,
-};