@oondemand/oon-core-back 0.3.55 → 0.3.57

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

@@ -0,0 +1,123 @@
+"use strict";
+
+const GenericError = require("../../../core/errors/GenericError");
+const { getIntegrationModels } = require("../models");
+const { getIntegrationProvider, resolveWebhookHandler } = require("../registry");
+const { sanitizeIntegrationError, sanitizeIntegrationValue } = require("../sanitizer");
+const { acquireNext, finalizeLease, leaseHeartbeat } = require("./lease");
+const { runTrackedOperation } = require("./tracking");
+const { DEFAULT_LEASE_MS, calculateBackoff, classifyError, isEnabled, payloadHash, workerId } = require("./utils");
+
+async function receiveWebhook(input) {
+  const provider = getIntegrationProvider(input.provider);
+  if (typeof provider.verifyWebhook === "function") {
+    const accepted = await provider.verifyWebhook({
+      token: input.token,
+      headers: input.headers || {},
+      payload: input.payload,
+    });
+    if (!accepted) throw new GenericError("Webhook de integração não autorizado.", { statusCode: 401 });
+  }
+
+  const sanitizedPayload = sanitizeIntegrationValue(input.payload || {});
+  const hash = payloadHash(sanitizedPayload);
+  const externalEventId = String(input.externalEventId || "").trim();
+  const deduplicationKey = `${provider.key}:${externalEventId || hash}`;
+  const { Inbox } = getIntegrationModels();
+  return Inbox.findOneAndUpdate(
+    { deduplicationKey },
+    {
+      $setOnInsert: {
+        provider: provider.key,
+        resource: String(input.resource || ""),
+        eventType: String(input.eventType || "unknown"),
+        externalEventId,
+        deduplicationKey,
+        payloadHash: hash,
+        payload: sanitizedPayload,
+        receivedAt: new Date(),
+        status: "Pendente",
+        attempts: 0,
+        nextAttemptAt: new Date(),
+      },
+    },
+    { upsert: true, new: true, setDefaultsOnInsert: true },
+  ).lean();
+}
+
+async function processWebhookInbox(options = {}) {
+  const { Inbox } = getIntegrationModels();
+  const limit = Math.min(500, Math.max(1, Number(options.limit || 20)));
+  const worker = options.worker || workerId("inbox");
+  const leaseMs = Number(options.leaseMs || DEFAULT_LEASE_MS);
+  const results = [];
+
+  for (let index = 0; index < limit; index += 1) {
+    const query = { status: { $in: ["Pendente", "Erro temporário", "Processando"] } };
+    if (options.provider) query.provider = String(options.provider).trim().toLowerCase();
+    const event = await acquireNext(Inbox, query, { worker, leaseMs });
+    if (!event) break;
+    const pulse = leaseHeartbeat(Inbox, event, options);
+    pulse.start();
+    let provider;
+    try {
+      const resolved = resolveWebhookHandler(event.provider, event.eventType);
+      provider = resolved.provider;
+      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: "webhook",
+        title: `${provider.label}: webhook ${event.eventType}`,
+        metadata: {
+          source: "inbox",
+          inboxId: String(event._id),
+          externalEventId: event.externalEventId || "",
+        },
+        runner: (trace) => handler(event, {
+          ...options,
+          ...trace,
+          provider,
+          heartbeat: pulse.beat,
+          sanitize: sanitizeIntegrationValue,
+        }),
+      });
+      const committed = await finalizeLease(Inbox, event, {
+        status: "Concluído",
+        processedAt: new Date(),
+        lastError: {},
+        nextAttemptAt: null,
+      });
+      if (!committed) {
+        throw new GenericError("Resultado do webhook ignorado porque o lease expirou.", { statusCode: 409 });
+      }
+      results.push({ id: String(event._id), status: "Concluído", response: tracked.result });
+    } catch (error) {
+      const effectiveProvider = provider || { maxAttempts: 1, retryPolicy: { jitter: false } };
+      const classification = classifyError(effectiveProvider, error, Number(event.attempts || 1));
+      const committed = await finalizeLease(Inbox, event, {
+        status: classification.definitive ? "Erro definitivo" : "Erro temporário",
+        lastError: sanitizeIntegrationError(error),
+        nextAttemptAt: classification.definitive
+          ? null
+          : new Date(Date.now() + calculateBackoff(event.attempts, effectiveProvider.retryPolicy)),
+      });
+      if (!committed) {
+        throw new GenericError("Erro do webhook ignorado porque o lease expirou.", { statusCode: 409 });
+      }
+      results.push({
+        id: String(event._id),
+        status: classification.definitive ? "Erro definitivo" : "Erro temporário",
+        error: sanitizeIntegrationError(error),
+      });
+    } finally {
+      pulse.stop();
+    }
+  }
+  return { processed: results.filter((item) => item.status === "Concluído").length, results };
+}
+
+module.exports = { processWebhookInbox, receiveWebhook };

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = {
+  ...require("./runtime/inbox"),
+  ...require("./runtime/lease"),
+  ...require("./runtime/outbox"),
+  ...require("./runtime/sync"),
+  ...require("./runtime/tracking"),
+  ...require("./runtime/utils"),
+};