@oondemand/oon-core-back 0.4.23 → 0.4.25

package/README.md

@@ -15,6 +15,13 @@ O Core suporta `ecosystem.role` em `central.config.js`: `root` para a Central de
 
 Compatibilidade temporária: `CENTRAL_ATIVACAO_BACKEND_URL` e `MEUS_APPS_BACKEND_URL` continuam aceitas como aliases da URL da API. Nunca aponte a URL da API para o próprio Core.
 
+## Saúde operacional
+
+- `GET /health/ready`: retorna HTTP 200 somente quando o MongoDB está conectado; retorna 503 enquanto o runtime não estiver pronto.
+- `GET /health/version`: expõe as versões do OonCore e da Central, commit, release, build e ambiente da publicação.
+
+Na imagem de entrega, essas rotas são publicadas pelo Nginx sob `/api/health/ready` e `/api/health/version`.
+
 ## Fluxo
 
 `GET /ativacao/status` informa estado sem segredos. `POST /ativacao/validar-codigo` valida sem consumir. `POST /ativacao/concluir` revalida, chama `/ativar`, criptografa imediatamente o token da instância, executa hooks declarativos, chama `/concluir` e marca a instância como `ativa`. `POST /ativacao/tentar-novamente` retoma uma ativação já registrada sem exigir novo código.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oondemand/oon-core-back",
-  "version": "0.4.23",
+  "version": "0.4.25",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oondemand/oon-platform.git",

package/src/api/status.routes.js

@@ -1,21 +1,65 @@
+"use strict";
+
 const express = require("express");
 const mongoose = require("mongoose");
 const ctx = require("../core/context");
+const { runtimeSummary } = require("./core.routes");
 
 const router = express.Router();
 
-router.get("/", (_req, res) => {
-  const states = {
-    0: "Desconectado",
-    1: "Conectado",
-    2: "Conectando",
-    3: "Desconectando",
+const DATABASE_STATES = Object.freeze({
+  0: { code: "disconnected", label: "Desconectado" },
+  1: { code: "connected", label: "Conectado" },
+  2: { code: "connecting", label: "Conectando" },
+  3: { code: "disconnecting", label: "Desconectando" },
+});
+
+function databaseState(readyState = mongoose.connection.readyState) {
+  return DATABASE_STATES[readyState] || {
+    code: "unknown",
+    label: "Status desconhecido",
+  };
+}
+
+function readinessSummary(readyState = mongoose.connection.readyState) {
+  const database = databaseState(readyState);
+  const ready = readyState === 1;
+  return {
+    status: ready ? "ready" : "not_ready",
+    service: ctx.config.serviceName,
+    database: {
+      ready,
+      state: database.code,
+    },
+  };
+}
+
+function versionSummary() {
+  return {
+    status: "ok",
+    service: ctx.config.serviceName,
+    ...runtimeSummary(),
   };
-  const dbState = mongoose.connection.readyState;
+}
+
+router.get("/", (_req, res) => {
+  const database = databaseState();
   res.status(200).json({
     message: `${ctx.config.serviceName} rodando - vs ${ctx.config.serviceVersion}`,
-    database: states[dbState] || "Status desconhecido",
+    database: database.label,
   });
 });
 
+router.get("/health/ready", (_req, res) => {
+  const summary = readinessSummary();
+  res.status(summary.database.ready ? 200 : 503).json(summary);
+});
+
+router.get("/health/version", (_req, res) => {
+  res.status(200).json(versionSummary());
+});
+
 module.exports = router;
+module.exports.databaseState = databaseState;
+module.exports.readinessSummary = readinessSummary;
+module.exports.versionSummary = versionSummary;

package/src/delivery/mongoProvisioning.js

@@ -4,6 +4,12 @@ const { mongo } = require("mongoose");
 
 const DIGITALOCEAN_API = "https://api.digitalocean.com/v2";
 const DIGITALOCEAN_HOST_SUFFIX = ".mongo.ondigitalocean.com";
+const DIGITALOCEAN_RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+const DIGITALOCEAN_SERVER_STATUS = new Set([500, 502, 503, 504]);
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 function randomSecret(bytes = 32) {
   return require("node:crypto").randomBytes(bytes).toString("base64url");
@@ -177,58 +183,108 @@ async function digitalOceanRequest(
     body,
     expected = [200],
   },
-  { fetchImpl = globalThis.fetch } = {},
+  {
+    fetchImpl = globalThis.fetch,
+    sleepImpl = delay,
+    retryAttempts = 3,
+    retryBaseDelayMs = 1000,
+  } = {},
 ) {
   if (!fetchImpl) throw new Error("fetch não disponível para a DigitalOcean API.");
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 20000);
-  let response;
-  try {
-    response = await fetchImpl(
-      `${DIGITALOCEAN_API}/databases/${encodeURIComponent(clusterId)}${path}`,
-      {
-        method,
-        headers: {
-          Authorization: `Bearer ${token}`,
-          Accept: "application/json",
-          ...(body ? { "Content-Type": "application/json" } : {}),
+  const attempts = Math.max(1, Number(retryAttempts) || 3);
+
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 20000);
+    let response;
+    try {
+      response = await fetchImpl(
+        `${DIGITALOCEAN_API}/databases/${encodeURIComponent(clusterId)}${path}`,
+        {
+          method,
+          headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            ...(body ? { "Content-Type": "application/json" } : {}),
+          },
+          body: body ? JSON.stringify(body) : undefined,
+          signal: controller.signal,
         },
-        body: body ? JSON.stringify(body) : undefined,
-        signal: controller.signal,
-      },
-    );
-  } catch (error) {
-    if (error.name === "AbortError") {
-      throw new Error("Timeout ao acessar a DigitalOcean API.");
+      );
+    } catch (error) {
+      if (attempt < attempts) {
+        await sleepImpl(Math.min(10000, retryBaseDelayMs * 2 ** (attempt - 1)));
+        continue;
+      }
+      if (error.name === "AbortError") {
+        throw new Error("Timeout ao acessar a DigitalOcean API.");
+      }
+      throw new Error(`Falha ao acessar a DigitalOcean API: ${error.message}`);
+    } finally {
+      clearTimeout(timeout);
+    }
+
+    const payload = await response.json().catch(() => ({}));
+    if (expected.includes(response.status)) {
+      return { status: response.status, payload };
     }
-    throw new Error(`Falha ao acessar a DigitalOcean API: ${error.message}`);
-  } finally {
-    clearTimeout(timeout);
-  }
 
-  const payload = await response.json().catch(() => ({}));
-  if (!expected.includes(response.status)) {
+    if (
+      DIGITALOCEAN_RETRYABLE_STATUS.has(response.status)
+      && attempt < attempts
+    ) {
+      const retryAfter = Number(response.headers?.get?.("retry-after"));
+      const backoff = Number.isFinite(retryAfter) && retryAfter > 0
+        ? retryAfter * 1000
+        : retryBaseDelayMs * 2 ** (attempt - 1);
+      await sleepImpl(Math.min(10000, backoff));
+      continue;
+    }
+
+    const providerMessage = String(payload.message || payload.id || "erro")
+      .replace(/[\r\n]+/g, " ")
+      .slice(0, 300);
+    const providerRequestId = String(payload.request_id || "")
+      .replace(/[^A-Za-z0-9_.:-]/g, "")
+      .slice(0, 120);
     const error = new Error(
-      `DigitalOcean API rejeitou ${method} ${path}: HTTP ${response.status} (${payload.id || "erro"}).`,
+      `DigitalOcean API rejeitou ${method} ${path}: HTTP ${response.status} (${providerMessage})`
+      + (providerRequestId ? ` [requestId: ${providerRequestId}]` : "")
+      + ".",
     );
     error.status = response.status;
     error.payload = payload;
+    error.providerRequestId = providerRequestId || undefined;
     throw error;
   }
-  return { status: response.status, payload };
+
+  throw new Error("DigitalOcean API não concluiu a solicitação.");
 }
 
 async function ensureDigitalOceanDatabase(options, deps) {
   const path = `/dbs/${encodeURIComponent(options.dbName)}`;
+  let exists = false;
   try {
     await digitalOceanRequest(
       { ...options, path, expected: [200] },
       deps,
     );
-    return;
+    exists = true;
   } catch (error) {
-    if (error.status !== 404) throw error;
+    if (error.status === 404) {
+      exists = false;
+    } else if (DIGITALOCEAN_SERVER_STATUS.has(error.status)) {
+      const listed = await digitalOceanRequest(
+        { ...options, path: "/dbs", expected: [200] },
+        deps,
+      );
+      exists = Array.isArray(listed.payload.dbs)
+        && listed.payload.dbs.some((item) => item?.name === options.dbName);
+    } else {
+      throw error;
+    }
   }
+  if (exists) return;
 
   await digitalOceanRequest(
     {
@@ -253,15 +309,28 @@ function digitalOceanUserSettings(dbName) {
 
 async function provisionDigitalOceanUser(options, deps) {
   const userPath = `/users/${encodeURIComponent(options.username)}`;
-  let exists = true;
+  let exists = false;
   try {
     await digitalOceanRequest(
       { ...options, path: userPath, expected: [200] },
       deps,
     );
+    exists = true;
   } catch (error) {
-    if (error.status !== 404) throw error;
-    exists = false;
+    if (error.status === 404) {
+      exists = false;
+    } else if (DIGITALOCEAN_SERVER_STATUS.has(error.status)) {
+      const listed = await digitalOceanRequest(
+        { ...options, path: "/users", expected: [200] },
+        deps,
+      );
+      exists = Array.isArray(listed.payload.users)
+        && listed.payload.users.some(
+          (item) => item?.name === options.username,
+        );
+    } else {
+      throw error;
+    }
   }
 
   const settings = digitalOceanUserSettings(options.dbName);
@@ -378,6 +447,8 @@ async function provisionMongo(options, deps = {}) {
 module.exports = {
   DIGITALOCEAN_API,
   DIGITALOCEAN_HOST_SUFFIX,
+  DIGITALOCEAN_RETRYABLE_STATUS,
+  DIGITALOCEAN_SERVER_STATUS,
   mongoIdentity,
   mongoHost,
   resolveMongoProvisioner,