@oondemand/oon-core-back 0.5.6 → 0.6.0

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

@@ -1,94 +0,0 @@
-"use strict";
-
-const crypto = require("node:crypto");
-const GenericError = require("../../../core/errors/GenericError");
-const { DEFAULT_HEARTBEAT_MS, DEFAULT_LEASE_MS } = require("./utils");
-
-async function acquireNext(Model, query, { worker, leaseMs }) {
-  const now = new Date();
-  const leaseId = crypto.randomUUID();
-  const document = await Model.findOneAndUpdate(
-    {
-      ...query,
-      $and: [
-        {
-          $or: [
-            { nextAttemptAt: { $lte: now } },
-            { nextAttemptAt: null },
-            { nextAttemptAt: { $exists: false } },
-          ],
-        },
-        {
-          $or: [
-            { leaseExpiresAt: { $lte: now } },
-            { leaseExpiresAt: null },
-            { leaseExpiresAt: { $exists: false } },
-          ],
-        },
-      ],
-    },
-    {
-      $set: {
-        status: "Processando",
-        leaseId,
-        lockedAt: now,
-        lockedBy: worker,
-        heartbeatAt: now,
-        leaseExpiresAt: new Date(now.getTime() + leaseMs),
-      },
-      $inc: { attempts: 1 },
-    },
-    { sort: { createdAt: 1, receivedAt: 1 }, new: true },
-  ).lean();
-  return document ? { ...document, leaseId } : null;
-}
-
-async function heartbeat(Model, id, leaseId, leaseMs = DEFAULT_LEASE_MS) {
-  const now = new Date();
-  const result = await Model.updateOne(
-    { _id: id, leaseId, status: "Processando" },
-    { $set: { heartbeatAt: now, leaseExpiresAt: new Date(now.getTime() + leaseMs) } },
-  );
-  if (result.matchedCount !== 1) {
-    throw new GenericError("Lease da integração não pertence mais a este worker.", { statusCode: 409 });
-  }
-}
-
-function leaseHeartbeat(Model, document, options = {}) {
-  const leaseMs = Number(options.leaseMs || DEFAULT_LEASE_MS);
-  const intervalMs = Math.min(leaseMs / 2, Number(options.heartbeatMs || DEFAULT_HEARTBEAT_MS));
-  let timer;
-  let stopped = false;
-  const beat = () => heartbeat(Model, document._id, document.leaseId, leaseMs);
-  return {
-    start() {
-      timer = setInterval(() => {
-        beat().catch((error) => {
-          if (!stopped) console.error("[integration-heartbeat]", error.message);
-        });
-      }, intervalMs);
-      timer.unref?.();
-    },
-    async beat() { return beat(); },
-    stop() { stopped = true; if (timer) clearInterval(timer); },
-  };
-}
-
-async function finalizeLease(Model, event, patch) {
-  const result = await Model.updateOne(
-    { _id: event._id, leaseId: event.leaseId, status: "Processando" },
-    {
-      $set: {
-        ...patch,
-        leaseId: "",
-        lockedAt: null,
-        lockedBy: "",
-        leaseExpiresAt: null,
-        heartbeatAt: null,
-      },
-    },
-  );
-  return result.matchedCount === 1;
-}
-
-module.exports = { acquireNext, finalizeLease, heartbeat, leaseHeartbeat };

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

@@ -1,199 +0,0 @@
-"use strict";
-
-const GenericError = require("../../../core/errors/GenericError");
-const { getIntegrationModels } = require("../models");
-const { getIntegrationProvider, resolveIntegrationHandler } = require("../registry");
-const { sanitizeIntegrationError, sanitizeIntegrationValue } = require("../sanitizer");
-const { acquireNext, finalizeLease, leaseHeartbeat } = require("./lease");
-const { runTrackedOperation } = require("./tracking");
-const { DEFAULT_LEASE_MS, calculateBackoff, classifyError, isEnabled, workerId } = require("./utils");
-
-async function enqueueIntegration(input) {
-  const provider = getIntegrationProvider(input.provider);
-  const handler = String(input.handler || input.type || "").trim();
-  const idempotencyKey = String(input.idempotencyKey || "").trim();
-  if (!handler) throw new GenericError("Informe o handler da integração.", { statusCode: 422 });
-  if (!idempotencyKey) throw new GenericError("Informe a chave de idempotência.", { statusCode: 422 });
-  if (!provider.handlers[handler]) {
-    throw new GenericError(`Handler ${handler} não registrado para ${provider.label}.`, { statusCode: 422 });
-  }
-
-  const { Outbox } = getIntegrationModels();
-  return Outbox.findOneAndUpdate(
-    { idempotencyKey },
-    {
-      $setOnInsert: {
-        provider: provider.key,
-        handler,
-        resource: String(input.resource || ""),
-        operation: String(input.operation || "execute"),
-        aggregateType: String(input.aggregateType || ""),
-        aggregateId: String(input.aggregateId || ""),
-        idempotencyKey,
-        payload: sanitizeIntegrationValue(input.payload || {}),
-        status: "Pendente",
-        attempts: 0,
-        nextAttemptAt: new Date(),
-      },
-    },
-    { upsert: true, new: true, setDefaultsOnInsert: true },
-  ).lean();
-}
-
-async function processOutboxEvent(event, options = {}) {
-  const { Outbox } = getIntegrationModels();
-  const pulse = leaseHeartbeat(Outbox, event, options);
-  pulse.start();
-  let provider;
-  let handlerKey = event.handler;
-  try {
-    const resolved = resolveIntegrationHandler(event.provider, event.handler);
-    provider = resolved.provider;
-    handlerKey = resolved.handlerKey;
-    const handler = resolved.handler;
-    if (!isEnabled(provider)) {
-      throw new GenericError(`A integração ${provider.label} está desativada.`, { statusCode: 503 });
-    }
-    const tracked = await runTrackedOperation({
-      provider: provider.key,
-      resource: event.resource || "",
-      operation: event.operation || "execute",
-      title: `${provider.label}: ${handlerKey}`,
-      metadata: {
-        source: "outbox",
-        outboxId: String(event._id),
-        aggregateType: event.aggregateType || "",
-        aggregateId: event.aggregateId || "",
-        attempts: event.attempts,
-      },
-      runner: (trace) => handler(event, {
-        ...options,
-        ...trace,
-        provider,
-        heartbeat: pulse.beat,
-        sanitize: sanitizeIntegrationValue,
-      }),
-    });
-    const response = tracked.result;
-    const committed = await finalizeLease(Outbox, event, {
-      status: "Concluído",
-      completedAt: new Date(),
-      responseSummary: sanitizeIntegrationValue(tracked.summary || response || {}),
-      lastError: {},
-      nextAttemptAt: null,
-    });
-    if (!committed) throw new GenericError("Resultado ignorado porque o lease expirou.", { statusCode: 409 });
-    return { id: String(event._id), handler: handlerKey, status: "Concluído", response };
-  } catch (error) {
-    const attempts = Number(event.attempts || 1);
-    const effectiveProvider = provider || { maxAttempts: 1, retryPolicy: { jitter: false } };
-    const classification = classifyError(effectiveProvider, error, attempts);
-    const retryPolicy = { ...effectiveProvider.retryPolicy, ...(error?.retryPolicy || {}) };
-    const committed = await finalizeLease(Outbox, event, {
-      status: classification.definitive ? "Erro definitivo" : "Erro temporário",
-      lastError: sanitizeIntegrationError(error),
-      nextAttemptAt: classification.definitive
-        ? null
-        : new Date(Date.now() + calculateBackoff(attempts, retryPolicy)),
-    });
-    if (!committed) throw new GenericError("Erro ignorado porque o lease expirou.", { statusCode: 409 });
-    return {
-      id: String(event._id),
-      handler: handlerKey,
-      status: classification.definitive ? "Erro definitivo" : "Erro temporário",
-      error: sanitizeIntegrationError(error),
-    };
-  } finally {
-    pulse.stop();
-  }
-}
-
-async function processIntegrationQueue(options = {}) {
-  const { Outbox } = getIntegrationModels();
-  const limit = Math.min(500, Math.max(1, Number(options.limit || 20)));
-  const worker = options.worker || workerId("outbox");
-  const leaseMs = Number(options.leaseMs || DEFAULT_LEASE_MS);
-  const statuses = ["Pendente", "Erro temporário", "Processando"];
-  const results = [];
-
-  for (let index = 0; index < limit; index += 1) {
-    const query = { status: { $in: statuses } };
-    if (options.provider) query.provider = String(options.provider).trim().toLowerCase();
-    const event = await acquireNext(Outbox, query, { worker, leaseMs });
-    if (!event) break;
-    try {
-      results.push(await processOutboxEvent(event, options));
-    } catch (error) {
-      results.push({ id: String(event._id), status: "Erro", error: sanitizeIntegrationError(error) });
-    }
-  }
-
-  return {
-    processed: results.filter((item) => item.status === "Concluído").length,
-    errors: results.filter((item) => item.status !== "Concluído"),
-    results,
-  };
-}
-
-async function archiveIntegrationTicket(id, reason) {
-  const { Outbox } = getIntegrationModels();
-  const ticket = await Outbox.findById(id).lean();
-  if (!ticket) throw new GenericError("Ticket de integração não encontrado.", { statusCode: 404 });
-  if (!["Erro temporário", "Erro definitivo"].includes(ticket.status)) {
-    throw new GenericError("Somente tickets com erro podem ser arquivados.", { statusCode: 409 });
-  }
-  return Outbox.findOneAndUpdate(
-    { _id: id, status: ticket.status },
-    {
-      $set: {
-        previousStatus: ticket.status,
-        status: "Arquivado",
-        archivedAt: new Date(),
-        archiveReason: String(reason || "Erro reconhecido e arquivado manualmente.").slice(0, 500),
-        nextAttemptAt: null,
-        leaseId: "",
-        lockedAt: null,
-        lockedBy: "",
-        leaseExpiresAt: null,
-        heartbeatAt: null,
-      },
-    },
-    { new: true },
-  ).lean();
-}
-
-async function reprocessIntegrationTicket(id) {
-  const { Outbox } = getIntegrationModels();
-  const ticket = await Outbox.findById(id).lean();
-  if (!ticket) throw new GenericError("Ticket de integração não encontrado.", { statusCode: 404 });
-  if (!["Erro temporário", "Erro definitivo", "Arquivado"].includes(ticket.status)) {
-    throw new GenericError("Este ticket não permite reprocessamento.", { statusCode: 409 });
-  }
-  return Outbox.findOneAndUpdate(
-    { _id: id, status: ticket.status },
-    {
-      $set: {
-        previousStatus: ticket.status,
-        status: "Pendente",
-        attempts: 0,
-        nextAttemptAt: new Date(),
-        lastError: {},
-        archivedAt: null,
-        archiveReason: "",
-        leaseId: "",
-        lockedAt: null,
-        lockedBy: "",
-        leaseExpiresAt: null,
-        heartbeatAt: null,
-      },
-    },
-    { new: true },
-  ).lean();
-}
-
-module.exports = {
-  archiveIntegrationTicket,
-  enqueueIntegration,
-  processIntegrationQueue,
-  reprocessIntegrationTicket,
-};

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

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

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

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

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

@@ -1,96 +0,0 @@
-"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: 12,
-  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 binarySummary(value) {
-  const size = Number(value?.byteLength ?? value?.length ?? 0);
-  const type = value?.constructor?.name || "Binary";
-  return `[${type}:${size} bytes]`;
-}
-
-function bsonObjectId(value) {
-  if (!value || typeof value !== "object") return null;
-  const isObjectId = value._bsontype === "ObjectId" || value.constructor?.name === "ObjectId";
-  if (!isObjectId) return null;
-  if (typeof value.toHexString === "function") return value.toHexString();
-  const text = String(value);
-  return /^[a-f\d]{24}$/i.test(text) ? text : null;
-}
-
-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);
-
-  const objectId = bsonObjectId(value);
-  if (objectId) return objectId;
-  if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) return binarySummary(value);
-  if (value instanceof ArrayBuffer) return binarySummary(value);
-
-  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,
-};