@oondemand/oon-core-back 0.4.24 → 0.4.26

package/package.json

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

package/src/api/activation.routes.js

@@ -125,14 +125,50 @@ function translateProviderActivationError(error, fallback) {
 
   const timedOut = error.code === "ECONNABORTED";
   const statusCode = timedOut ? 504 : error.response?.status || 502;
+  const payload = error.response?.data;
+  const envelope = payload?.error && typeof payload.error === "object"
+    ? payload.error
+    : payload;
+  const responseHeaders = error.response?.headers;
+  const headerRequestId = typeof responseHeaders?.get === "function"
+    ? responseHeaders.get("x-request-id") || responseHeaders.get("x-correlation-id")
+    : responseHeaders?.["x-request-id"] || responseHeaders?.["x-correlation-id"];
+  const requestId = String(
+    envelope?.requestId
+    || envelope?.details?.requestId
+    || headerRequestId
+    || "",
+  ).trim();
+  const upstreamDetails = envelope?.details;
+  const details = upstreamDetails && typeof upstreamDetails === "object"
+    ? { ...upstreamDetails, ...(requestId ? { requestId } : {}) }
+    : {
+        ...(upstreamDetails !== undefined ? { upstream: upstreamDetails } : {}),
+        ...(requestId ? { requestId } : {}),
+      };
   const message =
-    error.response?.data?.message ||
-    error.response?.data?.error?.message ||
-    (timedOut
+    envelope?.message
+    || payload?.message
+    || (timedOut
       ? "A Central de Ativações não respondeu dentro do prazo."
       : fallback);
 
-  return new GenericError(message, { statusCode });
+  return new GenericError(message, {
+    statusCode,
+    code: envelope?.code || (timedOut ? "ACTIVATION_PROVIDER_TIMEOUT" : "ACTIVATION_PROVIDER_FAILED"),
+    details: Object.keys(details).length ? details : null,
+  });
+}
+
+async function activationProviderPost(...args) {
+  try {
+    return await providerPost(...args);
+  } catch (error) {
+    throw translateProviderActivationError(
+      error,
+      "A Central de Ativações recusou a operação.",
+    );
+  }
 }
 
 function idOf(value) {
@@ -522,7 +558,7 @@ router.post(
     });
 
     try {
-      const response = await providerPost(
+      const response = await activationProviderPost(
         req,
         PATHS.validar,
         providerPayload(req, codigoAtivacao),
@@ -601,14 +637,14 @@ router.post(
       });
     }
 
-    const preview = await providerPost(
+    const preview = await activationProviderPost(
       req,
       PATHS.validar,
       providerPayload(req, codigoAtivacao),
     );
     assertApp(preview.data);
 
-    const activated = await providerPost(
+    const activated = await activationProviderPost(
       req,
       PATHS.ativar,
       providerPayload(req, codigoAtivacao, { nomeInstancia, metadata: {} }),
@@ -682,7 +718,7 @@ async function complete(req, instance, config) {
       });
     }
 
-    await providerPost(
+    await activationProviderPost(
       req,
       PATHS.concluir,
       {
@@ -746,3 +782,4 @@ router.post(
 );
 
 module.exports = router;
+module.exports.translateProviderActivationError = translateProviderActivationError;

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,