@oondemand/oon-core-back 0.3.4 → 0.3.6

package/package.json

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

package/src/api/activation.routes.js

@@ -27,6 +27,7 @@ const { getAppCode, getBaseUrl } = require("../core/utils/activationProvider");
 
 const router = express.Router();
 const attempts = new Map();
+const DEV_LOCAL_PATH = "/integracao/dev-local/ativar-central";
 
 function rateLimit(req, res, next) {
   const key = req.ip || "local";
@@ -111,6 +112,46 @@ function requireRootBootstrapResult(result) {
   };
 }
 
+function readBasicAuthorization(req) {
+  const authorization = String(req.headers.authorization || "");
+  if (!authorization.startsWith("Basic ")) {
+    throw new GenericError("Informe e-mail e senha para ativar a Central.", {
+      statusCode: 401,
+    });
+  }
+  return authorization;
+}
+
+function translateProviderActivationError(error, fallback) {
+  if (error instanceof GenericError) return error;
+
+  const timedOut = error.code === "ECONNABORTED";
+  const statusCode = timedOut ? 504 : error.response?.status || 502;
+  const message =
+    error.response?.data?.message ||
+    error.response?.data?.error?.message ||
+    (timedOut
+      ? "A Central de Ativações não respondeu dentro do prazo."
+      : fallback);
+
+  return new GenericError(message, { statusCode });
+}
+
+function idOf(value) {
+  return value?.id || value?._id || value;
+}
+
+function summarizeDevInstance(data, appCode) {
+  const appId = idOf(data?.app);
+  return {
+    instanceId: `dev-local:${appId || appCode}`,
+    instanceCode: "dev-local",
+    appId: appId ? String(appId) : undefined,
+    tenantId: idOf(data?.tenant) ? String(idOf(data.tenant)) : undefined,
+    licencaId: idOf(data?.licenca) ? String(idOf(data.licenca)) : undefined,
+  };
+}
+
 router.use(rateLimit);
 
 router.get(
@@ -172,7 +213,8 @@ router.get(
       });
     }
 
-    const host = new URL(getBaseUrl(req)).hostname;
+    const centralAtivacaoUrl = getBaseUrl(req);
+    const host = new URL(centralAtivacaoUrl).hostname;
     return sendResponse({
       res,
       mode: "member-activation",
@@ -184,12 +226,14 @@ router.get(
         ...globalDefaults,
         ambiente: ambiente(),
         urlPublica: publicUrl(req),
+        nomeInstancia: ctx.config.name || ctx.config.slug || getAppCode(),
       },
       technical: {
         appCode: getAppCode(),
         ambiente: ambiente(),
         ecosystemRole: "member",
         centralAtivacaoHost: host,
+        centralAtivacaoUrl,
       },
     });
   }),
@@ -288,6 +332,149 @@ router.post(
   }),
 );
 
+router.post(
+  "/ativar-dev-local",
+  asyncHandler(async (req, res) => {
+    assertMember();
+
+    if (ambiente() !== "desenvolvimento") {
+      throw new GenericError(
+        "A ativação self-service está disponível somente em desenvolvimento.",
+        { statusCode: 403 },
+      );
+    }
+
+    const authorization = readBasicAuthorization(req);
+    const config = activationConfig();
+    const instance = await ensureInstance();
+
+    if (instance.status === "ativa") {
+      throw new GenericError("Instância já ativada.", { statusCode: 409 });
+    }
+
+    if (!["nao_ativada", "validando", "erro"].includes(instance.status)) {
+      throw new GenericError(
+        "Instância não pode ser ativada neste estado.",
+        { statusCode: 409 },
+      );
+    }
+
+    const appCode = getAppCode();
+    const nomeCentral =
+      req.body?.nomeCentral ||
+      req.body?.appName ||
+      ctx.config.name ||
+      ctx.config.slug ||
+      appCode;
+    const urlPublica = req.body?.urlPublica || publicUrl(req);
+
+    event("DEV_LOCAL_ACTIVATION_STARTED", {
+      correlationId: req.correlationId,
+      appCode,
+    });
+
+    try {
+      const response = await providerPost(
+        req,
+        DEV_LOCAL_PATH,
+        {
+          appCode,
+          codigoApp: appCode,
+          nomeCentral,
+          appName: req.body?.appName || nomeCentral,
+          appSlug: req.body?.appSlug || ctx.config.slug || appCode,
+          ambiente: "desenvolvimento",
+          urlPublica,
+          repositorio: req.body?.repositorio,
+          branch: req.body?.branch,
+          nomeUsuario: req.body?.nomeUsuario,
+          nomeTenant: req.body?.nomeTenant,
+        },
+        { Authorization: authorization },
+      );
+
+      const data = response.data || {};
+      assertApp(data);
+
+      const resolvedAppCode = String(
+        data.app?.codigo || data.appCode || appCode,
+      ).toLowerCase();
+      const ids = summarizeDevInstance(data, resolvedAppCode);
+      const now = new Date();
+
+      Object.assign(instance, {
+        status: "ativa",
+        ecosystemRole: "member",
+        instanceId: ids.instanceId,
+        instanceCode: ids.instanceCode,
+        appCode: resolvedAppCode,
+        appId: ids.appId,
+        tenantId: ids.tenantId,
+        licencaId: ids.licencaId,
+        ambiente: "desenvolvimento",
+        nomeInstancia: nomeCentral,
+        ecosystemUrl: getBaseUrl(req),
+        publicUrl: urlPublica,
+        coreVersion: process.env.npm_package_version || "0.0.0",
+        appVersion: process.env.SERVICE_VERSION || "0.1.0",
+        credentialEncrypted: undefined,
+        credentialIv: undefined,
+        credentialAuthTag: undefined,
+        credentialVersion: undefined,
+        tenant: data.tenant,
+        app: data.app,
+        licenca: data.licenca,
+        parametrosGlobais: {
+          ...globalDefaults,
+          nomeInstancia: nomeCentral,
+          ambiente: "desenvolvimento",
+          urlPublica,
+        },
+        parametrosAplicacao: {
+          devLocal: true,
+        },
+        configurationVersion: config.configurationVersion,
+        ativadaEm: now,
+        concluidaEm: now,
+        ultimaValidacaoEm: now,
+        ultimoErro: undefined,
+      });
+
+      await instance.save();
+
+      event("DEV_LOCAL_ACTIVATION_COMPLETED", {
+        correlationId: req.correlationId,
+        appCode: resolvedAppCode,
+      });
+
+      sendResponse({
+        res,
+        statusCode: 201,
+        ...data,
+        message: data.message || "Central ativada em desenvolvimento local.",
+        sucesso: true,
+        status: "ativa",
+        instanceId: instance.instanceId,
+      });
+    } catch (error) {
+      instance.status = "erro";
+      instance.ultimoErro = error.response?.data?.message || error.message;
+      await instance.save();
+
+      event("DEV_LOCAL_ACTIVATION_FAILED", {
+        correlationId: req.correlationId,
+        appCode,
+        status: error.response?.status,
+      });
+
+      throw translateProviderActivationError(
+        error,
+        "Não foi possível ativar a Central em desenvolvimento local.",
+      );
+    }
+  }),
+);
+
 router.post(
   "/validar-codigo",
   asyncHandler(async (req, res) => {

package/src/core/utils/activationProvider.js

@@ -1,25 +1,40 @@
 const GenericError = require("../errors/GenericError");
+const ctx = require("../context");
 
+const DEFAULT_CENTRAL_ATIVACAO_URL =
+  "https://central-ativacao.central.oondemand.online";
 const LOGIN_PATH = "/integracao/autenticacao-aplicativos/autenticar";
 const PERMISSION_PATH = "/integracao/autenticacao-aplicativos/verificar-permissao";
 
-function getBaseUrl(req) {
-  const value = process.env.CENTRAL_ATIVACAO_URL || process.env.MEUS_APPS_BACKEND_URL;
-  if (!value) {
-    throw new GenericError("CENTRAL_ATIVACAO_URL não configurada.", {
-      statusCode: 500,
-    });
-  }
+function uniq(values) {
+  return [...new Set(values.filter(Boolean))];
+}
 
+function normalizeBaseUrl(value, label) {
   let parsed;
   try {
     parsed = new URL(value);
   } catch {
-    throw new GenericError("CENTRAL_ATIVACAO_URL inválida.", {
+    throw new GenericError(`${label} inválida.`, {
       statusCode: 500,
     });
   }
 
+  return parsed.toString().replace(/\/$/, "");
+}
+
+function withApiPath(value) {
+  const parsed = new URL(value);
+  const cleanPath = parsed.pathname.replace(/\/$/, "");
+
+  if (cleanPath.endsWith("/api")) return null;
+
+  parsed.pathname = `${cleanPath}/api`.replace(/^\/\//, "/");
+  return parsed.toString().replace(/\/$/, "");
+}
+
+function assertNotSameHost(url, req) {
+  const parsed = new URL(url);
   const currentHost = String(
     req?.headers?.["x-forwarded-host"] || req?.headers?.host || "",
   )
@@ -37,8 +52,66 @@ function getBaseUrl(req) {
       { statusCode: 500 },
     );
   }
+}
 
-  return parsed.toString().replace(/\/$/, "");
+function readCentralActivationPublicUrl() {
+  return (
+    process.env.CENTRAL_ATIVACAO_URL ||
+    process.env.MEUS_APPS_BACKEND_URL ||
+    DEFAULT_CENTRAL_ATIVACAO_URL
+  );
+}
+
+function readCentralActivationApiUrl() {
+  return (
+    process.env.CENTRAL_ATIVACAO_API_URL ||
+    process.env.CENTRAL_ATIVACAO_BACKEND_URL ||
+    process.env.CENTRAL_ATIVACAO_URL ||
+    process.env.MEUS_APPS_BACKEND_URL ||
+    DEFAULT_CENTRAL_ATIVACAO_URL
+  );
+}
+
+function getBaseUrl(req) {
+  const value = normalizeBaseUrl(
+    readCentralActivationApiUrl(),
+    "CENTRAL_ATIVACAO_API_URL/CENTRAL_ATIVACAO_URL",
+  );
+  assertNotSameHost(value, req);
+  return value;
+}
+
+function getDisplayUrl(req) {
+  const value = normalizeBaseUrl(
+    readCentralActivationPublicUrl(),
+    "CENTRAL_ATIVACAO_URL",
+  );
+  assertNotSameHost(value, req);
+  return value;
+}
+
+function getBaseUrlCandidates(req) {
+  const explicitApi = process.env.CENTRAL_ATIVACAO_API_URL;
+  const raw = uniq([
+    process.env.CENTRAL_ATIVACAO_API_URL,
+    process.env.CENTRAL_ATIVACAO_BACKEND_URL,
+    process.env.CENTRAL_ATIVACAO_URL,
+    process.env.MEUS_APPS_BACKEND_URL,
+    DEFAULT_CENTRAL_ATIVACAO_URL,
+  ]);
+
+  const normalized = raw.map((value) =>
+    normalizeBaseUrl(value, "CENTRAL_ATIVACAO_API_URL/CENTRAL_ATIVACAO_URL"),
+  );
+
+  const expanded = explicitApi
+    ? normalized
+    : normalized.flatMap((value) => [value, withApiPath(value)]);
+
+  return uniq(expanded).map((url) => {
+    assertNotSameHost(url, req);
+    return url;
+  });
 }
 
 function getAppCode() {
@@ -47,6 +120,9 @@ function getAppCode() {
       process.env.APP_CODIGO ||
       process.env.OON_APP_CODE ||
       process.env.OON_APP_CODIGO ||
+      ctx.config.appCode ||
+      ctx.config.appCodigo ||
+      ctx.config.slug ||
       "",
   )
     .trim()
@@ -66,9 +142,12 @@ function getTimeout() {
 }
 
 module.exports = {
+  DEFAULT_CENTRAL_ATIVACAO_URL,
   LOGIN_PATH,
   PERMISSION_PATH,
   getBaseUrl,
+  getDisplayUrl,
+  getBaseUrlCandidates,
   getAppCode,
   getTimeout,
 };

package/src/core/utils/instanceActivation.js

@@ -4,7 +4,12 @@ const axios = require("axios");
 const ctx = require("../context");
 const GenericError = require("../errors/GenericError");
 const Instancia = require("../models/InstanciaEcossistema");
-const { getBaseUrl, getAppCode, getTimeout } = require("./activationProvider");
+const {
+  getBaseUrl,
+  getBaseUrlCandidates,
+  getAppCode,
+  getTimeout,
+} = require("./activationProvider");
 
 const PATHS = {
   validar: "/integracao/ativacao-instancias/validar-codigo",
@@ -430,12 +435,28 @@ function validateParams(globalParameters = {}, appParameters = {}) {
   }
 }
 
+function shouldTryNextProviderUrl(error) {
+  return [404, 405].includes(Number(error.response?.status));
+}
+
 async function providerPost(req, path, payload, headers = {}) {
-  return axios.post(`${getBaseUrl(req)}${path}`, payload, {
-    timeout: getTimeout(),
-    maxRedirects: 0,
-    headers: { "Content-Type": "application/json", ...headers },
-  });
+  const baseUrls = getBaseUrlCandidates(req);
+  let lastError;
+
+  for (const baseUrl of baseUrls) {
+    try {
+      return await axios.post(`${baseUrl}${path}`, payload, {
+        timeout: getTimeout(),
+        maxRedirects: 0,
+        headers: { "Content-Type": "application/json", ...headers },
+      });
+    } catch (error) {
+      lastError = error;
+      if (!shouldTryNextProviderUrl(error)) throw error;
+    }
+  }
+
+  throw lastError;
 }
 
 function providerPayload(req, codigoAtivacao, extra = {}) {