@oondemand/oon-core-back 0.3.57 → 0.3.58

package/src/modules/omie/definitions.js

@@ -0,0 +1,206 @@
+"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.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,
+      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,69 +1,33 @@
-const axios = require("axios");
-const registry = require("../../core/registry");
+"use strict";
 
-/**
- * Módulo Omie (Seção 12) — engine + fila + retry. O dev declara
- * `defineOmieMapping(...)` ou usa `omie.sync(...)` em triggers; toda a
- * mecânica de chamada/retentativa fica aqui.
- */
-const queue = [];
-let draining = false;
+const client = require("./client");
+const definitions = require("./definitions");
+const models = require("./models");
+const provider = require("./provider");
 
-async function callOmie({ endpoint, call, param }, { retries = 3 } = {}) {
-  const base = process.env.API_OMIE || "https://app.omie.com.br/api/v1";
-  const body = {
-    call,
-    app_key: process.env.OMIE_APP_KEY,
-    app_secret: process.env.OMIE_APP_SECRET,
-    param: Array.isArray(param) ? param : [param],
-  };
-
-  let lastErr;
-  for (let attempt = 1; attempt <= retries; attempt++) {
-    try {
-      const { data } = await axios.post(`${base}/${endpoint}/`, body);
-      return data;
-    } catch (err) {
-      lastErr = err;
-      await new Promise((r) => setTimeout(r, attempt * 500));
-    }
-  }
-  throw lastErr;
-}
-
-function enqueue(job) {
-  queue.push(job);
-  drain();
-}
-
-async function drain() {
-  if (draining) return;
-  draining = true;
-  while (queue.length) {
-    const job = queue.shift();
-    try {
-      await job();
-    } catch (err) {
-      console.log("[omie] job falhou:", err?.message);
-    }
-  }
-  draining = false;
-}
-
-/**
- * Helper usado em triggers: resolve o mapping registrado e enfileira o
- * sync. Se não houver app_key configurada, vira no-op seguro.
- */
 const omie = {
-  async sync({ mapping, payload, ...rest }) {
-    if (!process.env.OMIE_APP_KEY) return { skipped: true };
-    const def = mapping ? registry.listOmieMappings().find((m) => m.name === mapping) : null;
-    const request = def?.toOmie ? def.toOmie(payload) : { ...rest, param: payload };
-    return new Promise((resolve, reject) => {
-      enqueue(() => callOmie(request).then(resolve).catch(reject));
-    });
+  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 },
+    );
   },
-  call: callOmie,
 };
 
-module.exports = { omie };
+module.exports = {
+  ...client,
+  ...definitions,
+  ...models,
+  ...provider,
+  omie,
+};

package/src/modules/omie/models.js

@@ -0,0 +1,308 @@
+"use strict";
+
+const crypto = require("node:crypto");
+const mongoose = require("mongoose");
+const GenericError = require("../../core/errors/GenericError");
+
+const SECRET_PREFIX = "oon:v1";
+const DEFAULT_BASE_URL = "https://app.omie.com.br/api/v1";
+
+function encryptionSecret() {
+  return String(
+    process.env.OON_CREDENTIALS_ENCRYPTION_KEY
+    || process.env.OMIE_CREDENTIALS_ENCRYPTION_KEY
+    || "",
+  ).trim();
+}
+
+function encryptionKey() {
+  const secret = encryptionSecret();
+  if (!secret) {
+    throw new GenericError(
+      "Configure OON_CREDENTIALS_ENCRYPTION_KEY para persistir credenciais Omie.",
+      { statusCode: 503 },
+    );
+  }
+  return crypto.createHash("sha256").update(secret).digest();
+}
+
+function encryptSecret(value) {
+  const clear = String(value || "");
+  if (!clear) return "";
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", encryptionKey(), iv);
+  const encrypted = Buffer.concat([cipher.update(clear, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return [SECRET_PREFIX, iv.toString("base64url"), tag.toString("base64url"), encrypted.toString("base64url")].join(":");
+}
+
+function decryptSecret(value) {
+  const encrypted = String(value || "");
+  if (!encrypted) return "";
+  const [namespace, version, ivValue, tagValue, payloadValue] = encrypted.split(":");
+  if (`${namespace}:${version}` !== SECRET_PREFIX || !ivValue || !tagValue || !payloadValue) {
+    throw new GenericError("Credencial Omie armazenada em formato inválido.", { statusCode: 500 });
+  }
+  const decipher = crypto.createDecipheriv(
+    "aes-256-gcm",
+    encryptionKey(),
+    Buffer.from(ivValue, "base64url"),
+  );
+  decipher.setAuthTag(Buffer.from(tagValue, "base64url"));
+  return Buffer.concat([
+    decipher.update(Buffer.from(payloadValue, "base64url")),
+    decipher.final(),
+  ]).toString("utf8");
+}
+
+function maskSecret(value) {
+  const clear = String(value || "");
+  if (!clear) return "";
+  if (clear.length <= 4) return "••••";
+  return `${clear.slice(0, 2)}${"•".repeat(Math.min(8, clear.length - 4))}${clear.slice(-2)}`;
+}
+
+function normalizeInstanceId(value) {
+  const instanceId = String(value || "default").trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(instanceId)) {
+    throw new GenericError("Identificador da instância Omie inválido.", { statusCode: 422 });
+  }
+  return instanceId;
+}
+
+function configurationSchema() {
+  const schema = new mongoose.Schema({
+    instanceId: { type: String, required: true, unique: true, index: true },
+    label: { type: String, required: true, default: "Omie" },
+    active: { type: Boolean, default: true, index: true },
+    environment: { type: String, enum: ["homologation", "production"], default: "production" },
+    baseUrl: { type: String, required: true, default: DEFAULT_BASE_URL },
+    appKeyEncrypted: { type: String, default: "", select: false },
+    appSecretEncrypted: { type: String, default: "", select: false },
+    webhookTokenEncrypted: { type: String, default: "", select: false },
+    appKeyMasked: { type: String, default: "" },
+    credentialsConfigured: { type: Boolean, default: false },
+    connectionStatus: { type: String, enum: ["not-tested", "ok", "error"], default: "not-tested" },
+    lastConnectionError: { type: String, default: "" },
+    lastConnectionTestAt: { type: Date, default: null },
+  }, { timestamps: true, minimize: false, strict: true });
+  return schema;
+}
+
+function listStateSchema() {
+  const schema = new mongoose.Schema({
+    provider: { type: String, default: "omie", index: true },
+    instanceId: { type: String, required: true, index: true },
+    listKey: { type: String, required: true, index: true },
+    status: { type: String, default: "not-run", index: true },
+    cursor: { type: mongoose.Schema.Types.Mixed, default: null },
+    lastStartedAt: { type: Date, default: null },
+    lastCompletedAt: { type: Date, default: null },
+    summary: { type: mongoose.Schema.Types.Mixed, default: {} },
+    diagnostic: { type: mongoose.Schema.Types.Mixed, default: {} },
+  }, { timestamps: true, minimize: false, strict: true });
+  schema.index({ provider: 1, instanceId: 1, listKey: 1 }, { unique: true });
+  return schema;
+}
+
+function getOmieModels() {
+  return {
+    Configuration: mongoose.models.OonOmieConfiguration
+      || mongoose.model("OonOmieConfiguration", configurationSchema(), "oon_omie_configurations"),
+    ListState: mongoose.models.OonOmieListState
+      || mongoose.model("OonOmieListState", listStateSchema(), "oon_omie_list_states"),
+  };
+}
+
+function instanceEnvPrefix(instanceId) {
+  return normalizeInstanceId(instanceId).replace(/[^a-z0-9]/g, "_").toUpperCase();
+}
+
+function environmentCredentials(instanceId) {
+  const normalized = normalizeInstanceId(instanceId);
+  const prefix = instanceEnvPrefix(normalized);
+  const specific = normalized === "default" ? "OMIE" : `OMIE_${prefix}`;
+  return {
+    appKey: String(process.env[`${specific}_APP_KEY`] || "").trim(),
+    appSecret: String(process.env[`${specific}_APP_SECRET`] || "").trim(),
+    webhookToken: String(process.env[`${specific}_WEBHOOK_TOKEN`] || "").trim(),
+    baseUrl: String(process.env[`${specific}_BASE_URL`] || process.env.API_OMIE || DEFAULT_BASE_URL).trim(),
+  };
+}
+
+function publicConfiguration(document) {
+  if (!document) return null;
+  const value = typeof document.toObject === "function" ? document.toObject() : { ...document };
+  delete value.appKeyEncrypted;
+  delete value.appSecretEncrypted;
+  delete value.webhookTokenEncrypted;
+  return value;
+}
+
+async function listOmieConfigurations() {
+  const { Configuration } = getOmieModels();
+  const persisted = await Configuration.find({}).sort({ label: 1, instanceId: 1 }).lean();
+  if (persisted.length) return persisted.map(publicConfiguration);
+  const env = environmentCredentials("default");
+  return [{
+    instanceId: "default",
+    label: "Omie",
+    active: true,
+    environment: "production",
+    baseUrl: env.baseUrl,
+    appKeyMasked: maskSecret(env.appKey),
+    credentialsConfigured: Boolean(env.appKey && env.appSecret),
+    connectionStatus: "not-tested",
+    lastConnectionError: "",
+    lastConnectionTestAt: null,
+    source: "environment",
+  }];
+}
+
+async function saveOmieConfiguration(instanceId, input = {}) {
+  const normalized = normalizeInstanceId(instanceId);
+  const { Configuration } = getOmieModels();
+  const current = await Configuration.findOne({ instanceId: normalized })
+    .select("+appKeyEncrypted +appSecretEncrypted +webhookTokenEncrypted");
+  const update = {
+    instanceId: normalized,
+    label: String(input.label || current?.label || (normalized === "default" ? "Omie" : normalized)).trim(),
+    active: input.active !== undefined ? Boolean(input.active) : (current?.active ?? true),
+    environment: ["homologation", "production"].includes(input.environment)
+      ? input.environment
+      : (current?.environment || "production"),
+    baseUrl: String(input.baseUrl || current?.baseUrl || environmentCredentials(normalized).baseUrl || DEFAULT_BASE_URL)
+      .trim()
+      .replace(/\/+$/, ""),
+  };
+
+  const appKey = String(input.appKey || "").trim();
+  const appSecret = String(input.appSecret || "").trim();
+  const webhookToken = String(input.webhookToken || "").trim();
+  if (appKey) {
+    update.appKeyEncrypted = encryptSecret(appKey);
+    update.appKeyMasked = maskSecret(appKey);
+  } else if (current?.appKeyEncrypted) {
+    update.appKeyEncrypted = current.appKeyEncrypted;
+    update.appKeyMasked = current.appKeyMasked;
+  }
+  if (appSecret) update.appSecretEncrypted = encryptSecret(appSecret);
+  else if (current?.appSecretEncrypted) update.appSecretEncrypted = current.appSecretEncrypted;
+  if (webhookToken) update.webhookTokenEncrypted = encryptSecret(webhookToken);
+  else if (current?.webhookTokenEncrypted) update.webhookTokenEncrypted = current.webhookTokenEncrypted;
+
+  const env = environmentCredentials(normalized);
+  const effectiveKey = appKey || (current?.appKeyEncrypted ? decryptSecret(current.appKeyEncrypted) : env.appKey);
+  const effectiveSecret = appSecret
+    || (current?.appSecretEncrypted ? decryptSecret(current.appSecretEncrypted) : env.appSecret);
+  update.credentialsConfigured = Boolean(effectiveKey && effectiveSecret);
+  if (update.active && !update.credentialsConfigured) {
+    throw new GenericError(
+      "Configure App Key e App Secret antes de ativar a integração Omie.",
+      { statusCode: 422 },
+    );
+  }
+  if (appKey || appSecret || input.baseUrl) {
+    update.connectionStatus = "not-tested";
+    update.lastConnectionError = "";
+    update.lastConnectionTestAt = null;
+  }
+
+  const saved = await Configuration.findOneAndUpdate(
+    { instanceId: normalized },
+    { $set: update },
+    { upsert: true, new: true, setDefaultsOnInsert: true, runValidators: true },
+  ).lean();
+  return publicConfiguration(saved);
+}
+
+async function resolveOmieConfiguration(instanceId = "default", options = {}) {
+  const normalized = normalizeInstanceId(instanceId);
+  const { Configuration } = getOmieModels();
+  let query = Configuration.findOne({ instanceId: normalized });
+  if (options.includeSecrets) {
+    query = query.select("+appKeyEncrypted +appSecretEncrypted +webhookTokenEncrypted");
+  }
+  const persisted = await query.lean();
+  const env = environmentCredentials(normalized);
+  if (!persisted) {
+    return {
+      instanceId: normalized,
+      label: normalized === "default" ? "Omie" : normalized,
+      active: true,
+      environment: "production",
+      baseUrl: env.baseUrl,
+      appKey: options.includeSecrets ? env.appKey : undefined,
+      appSecret: options.includeSecrets ? env.appSecret : undefined,
+      webhookToken: options.includeSecrets ? env.webhookToken : undefined,
+      appKeyMasked: maskSecret(env.appKey),
+      credentialsConfigured: Boolean(env.appKey && env.appSecret),
+      connectionStatus: "not-tested",
+      source: "environment",
+    };
+  }
+  const result = publicConfiguration(persisted);
+  if (options.includeSecrets) {
+    result.appKey = persisted.appKeyEncrypted ? decryptSecret(persisted.appKeyEncrypted) : env.appKey;
+    result.appSecret = persisted.appSecretEncrypted ? decryptSecret(persisted.appSecretEncrypted) : env.appSecret;
+    result.webhookToken = persisted.webhookTokenEncrypted
+      ? decryptSecret(persisted.webhookTokenEncrypted)
+      : env.webhookToken;
+  }
+  return result;
+}
+
+async function updateConnectionStatus(instanceId, result = {}) {
+  const normalized = normalizeInstanceId(instanceId);
+  const { Configuration } = getOmieModels();
+  await Configuration.updateOne(
+    { instanceId: normalized },
+    {
+      $set: {
+        connectionStatus: result.ok ? "ok" : "error",
+        lastConnectionError: result.ok ? "" : String(result.error || "Falha na conexão."),
+        lastConnectionTestAt: new Date(),
+      },
+    },
+  );
+}
+
+async function resolveInstanceByWebhookToken(token) {
+  const candidate = String(token || "");
+  if (!candidate) return null;
+  const { Configuration } = getOmieModels();
+  const configurations = await Configuration.find({ active: true })
+    .select("+webhookTokenEncrypted")
+    .lean();
+  for (const configuration of configurations) {
+    if (!configuration.webhookTokenEncrypted) continue;
+    const expected = decryptSecret(configuration.webhookTokenEncrypted);
+    const left = Buffer.from(candidate);
+    const right = Buffer.from(expected);
+    if (left.length === right.length && crypto.timingSafeEqual(left, right)) {
+      return configuration.instanceId;
+    }
+  }
+  const env = environmentCredentials("default");
+  if (env.webhookToken) {
+    const left = Buffer.from(candidate);
+    const right = Buffer.from(env.webhookToken);
+    if (left.length === right.length && crypto.timingSafeEqual(left, right)) return "default";
+  }
+  return null;
+}
+
+module.exports = {
+  DEFAULT_BASE_URL,
+  decryptSecret,
+  encryptSecret,
+  getOmieModels,
+  listOmieConfigurations,
+  maskSecret,
+  normalizeInstanceId,
+  publicConfiguration,
+  resolveInstanceByWebhookToken,
+  resolveOmieConfiguration,
+  saveOmieConfiguration,
+  updateConnectionStatus,
+};