@ecdt/server-common 1.0.5 → 1.1.0

package/README.md

@@ -8,7 +8,7 @@ Conjunto de ferramentas e configurações comuns para servidores Express da Econ
 
 `@ecdt/server-common` fornece um conjunto de middlewares pré-configurados para aplicações Express, eliminando a necessidade de configurar manualmente o parsing de requisições e a sanitização de tokens em cada serviço.
 
-### `expressCommonMiddlewares()`
+### `expressCommonMiddlewares(options?)`
 
 Retorna um array com os seguintes middlewares já configurados, prontos para serem aplicados no Express via `app.use()`:
 
@@ -26,7 +26,24 @@ Este middleware normaliza tokens de autenticação que chegam codificados na URL
 1. O header `Authorization` — se presente, sanitiza o valor diretamente.
 2. O cookie da requisição — se não houver `Authorization`, extrai o token do cookie de sessão e o define em `req.headers.authorization`.
 
-> **Atenção:** O nome do cookie de sessão é determinado pela variável de ambiente `ENV`. Se `ENV=hml`, o cookie esperado é `hml-ecdt_token_site`; nos demais ambientes (`beta`, `prd`), é `ecdt_token_site`.
+#### Resolução do nome do cookie de sessão
+
+Por padrão, o nome do cookie é resolvido **por requisição**, a partir da origem (`Origin` > `Referer` > `Host`):
+
+- Origem com subdomínio `hml` (ex: `hml.econodata.com.br`, `api.hml.econodata.com.br`, `hml-site.econodata.com.br`) → cookie `hml-ecdt_token_site`
+- Demais origens → cookie `ecdt_token_site`
+
+Em ambos os casos, se o cookie preferido não existir na requisição, o outro nome é usado como fallback. A busca é por **match exato** do nome do cookie.
+
+Também é possível fixar o nome explicitamente via `options.cookieName` (string ou array em ordem de preferência), ignorando a detecção por origem:
+
+```js
+// Nome fixo
+app.use(...expressCommonMiddlewares({ cookieName: "hml-ecdt_token_site" }));
+
+// Múltiplos nomes, em ordem de preferência
+app.use(...expressCommonMiddlewares({ cookieName: ["hml-ecdt_token_site", "ecdt_token_site"] }));
+```
 
 ### `expressCors(options)`
 
@@ -34,7 +51,8 @@ Retorna o middleware de CORS padrão dos servidores Econodata (baseado no pacote
 
 | Opção | Tipo | Descrição |
 |---|---|---|
-| `origins` | `string[]` (obrigatório) | Origins permitidas. Requisições de outras origins não recebem os headers CORS (o navegador bloqueia a resposta) |
+| `origins` | `string[]` | Origins permitidas. Requisições de outras origins não recebem os headers CORS (o navegador bloqueia a resposta). Obrigatório se `econodataOrigins` não for `true` |
+| `econodataOrigins` | `boolean` | Permite todas as origins `https` do domínio `econodata.com.br` (qualquer subdomínio, ex: `https://app.econodata.com.br`, `https://api.hml.econodata.com.br`) |
 | `extraHeaders` | `string[]` | Headers adicionais além dos padrões |
 | `headers` | `string[]` | Lista **exata** de headers permitidos — substitui os padrões. Não combinar com `extraHeaders` |
 | `methods` | `string[]` | Lista **exata** de métodos permitidos. Default: todos (`GET, HEAD, PUT, PATCH, POST, DELETE, OPTIONS`) |
@@ -48,6 +66,12 @@ const { expressCors } = require("@ecdt/server-common");
 // Configuração mínima
 app.use(expressCors({ origins: ["https://app.econodata.com.br"] }));
 
+// Todas as origins do domínio econodata.com.br (qualquer subdomínio)
+app.use(expressCors({ econodataOrigins: true }));
+
+// Combinando econodataOrigins com origins extras
+app.use(expressCors({ econodataOrigins: true, origins: ["http://localhost:3000"] }));
+
 // Headers extras além dos padrões
 app.use(expressCors({ origins: [...], extraHeaders: ["X-Custom-Header"] }));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecdt/server-common",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Conjunto de ferramentas e configurações comuns nos servidores da Econodata",
   "main": "src/index.js",
   "scripts": {

package/src/index.d.ts

@@ -1,15 +1,28 @@
 declare module '@ecdt/server-common' {
+    export interface ExpressCommonMiddlewaresOptions {
+        /**
+         * Nome(s) do cookie de sessão, em ordem de preferência.
+         * Quando omitido, o nome é resolvido por requisição a partir da origem (origin > referer > host):
+         * origens com subdomínio "hml" usam `hml-ecdt_token_site`, as demais usam `ecdt_token_site`.
+         */
+        cookieName?: string | string[];
+    }
+
     /**
-     * Aplica bodyParser.text(), bodyParser.json(), bodyParser.urlencoded({extended: false}) e devMktTokenSanitaze() 
+     * Aplica bodyParser.text(), bodyParser.json(), bodyParser.urlencoded({extended: false}) e devMktTokenSanitaze()
      * no middleware do express.
-     * 
+     *
      * Uso: app.use(...expressCommonMiddlewares())
      */
-    export function expressCommonMiddlewares(): (req: unknown, res: unknown, next: (err?: unknown) => void) => void;
+    export function expressCommonMiddlewares(
+        options?: ExpressCommonMiddlewaresOptions
+    ): Array<(req: unknown, res: unknown, next: (err?: unknown) => void) => void>;
 
     export interface ExpressCorsOptions {
-        /** Origins permitidas (ex: ["https://app.econodata.com.br"]). Obrigatório. */
-        origins: string[];
+        /** Origins permitidas (ex: ["https://app.econodata.com.br"]). Obrigatório se econodataOrigins não for true. */
+        origins?: string[];
+        /** Permite todas as origins https do domínio econodata.com.br (qualquer subdomínio). */
+        econodataOrigins?: boolean;
         /** Headers adicionais além dos padrões (Authorization, Content-Type, X-Requested-With). */
         extraHeaders?: string[];
         /** Lista exata de headers permitidos — substitui os padrões. Não combinar com extraHeaders. */

package/src/index.js

@@ -2,8 +2,8 @@ const bodyParser = require("body-parser");
 const { devMktTokenSanitaze } = require("./services/tokenService.js");
 const { expressCors } = require("./services/corsService.js");
 
-function expressCommonMiddlewares(){
-    return [bodyParser.text(), bodyParser.json(), bodyParser.urlencoded({extended: false}), devMktTokenSanitaze];
+function expressCommonMiddlewares({ cookieName } = {}){
+    return [bodyParser.text(), bodyParser.json(), bodyParser.urlencoded({extended: false}), devMktTokenSanitaze({ cookieName })];
 }
 
 

package/src/services/corsService.js

@@ -2,17 +2,22 @@ const cors = require("cors");
 
 const DEFAULT_HEADERS = ["Authorization", "Content-Type", "X-Requested-With"];
 
+// Qualquer subdomínio (em qualquer nível) de econodata.com.br via https, incluindo o domínio raiz
+const ECONODATA_ORIGINS_REGEX = /^https:\/\/([a-z0-9-]+\.)*econodata\.com\.br$/;
+
 /**
  * @param {object} options
- * @param {string[]} options.origins - Origins permitidas (ex: ["https://app.econodata.com.br"])
+ * @param {string[]} [options.origins] - Origins permitidas (ex: ["https://app.econodata.com.br"])
+ * @param {boolean} [options.econodataOrigins] - Permite todas as origins https do domínio econodata.com.br (qualquer subdomínio)
  * @param {string[]} [options.extraHeaders] - Headers adicionais além dos padrões
  * @param {string[]} [options.headers] - Lista exata de headers (ignora os padrões e extraHeaders)
  * @param {string[]} [options.methods] - Lista exata de métodos permitidos (default: todos)
  * @returns middleware do express
  */
-function expressCors({ origins, extraHeaders, headers, methods } = {}) {
-    if (!Array.isArray(origins) || origins.length === 0) {
-        throw new Error("expressCors: 'origins' é obrigatório e deve ser um array com pelo menos uma origin");
+function expressCors({ origins, econodataOrigins, extraHeaders, headers, methods } = {}) {
+    const hasOrigins = Array.isArray(origins) && origins.length > 0;
+    if (!hasOrigins && !econodataOrigins) {
+        throw new Error("expressCors: informe 'origins' (array com pelo menos uma origin) e/ou 'econodataOrigins: true'");
     }
     if (headers && extraHeaders) {
         throw new Error("expressCors: use 'headers' OU 'extraHeaders', não os dois ao mesmo tempo");
@@ -20,12 +25,17 @@ function expressCors({ origins, extraHeaders, headers, methods } = {}) {
 
     const allowedHeaders = headers ?? [...DEFAULT_HEADERS, ...(extraHeaders ?? [])];
 
+    const allowedOrigins = [
+        ...(hasOrigins ? origins : []),
+        ...(econodataOrigins ? [ECONODATA_ORIGINS_REGEX] : []),
+    ];
+
     return cors({
-        origin: origins,
+        origin: allowedOrigins,
         credentials: true,
         allowedHeaders,
         methods: methods ?? ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE", "OPTIONS"],
     });
 }
 
-module.exports = { expressCors, DEFAULT_HEADERS };
+module.exports = { expressCors, DEFAULT_HEADERS, ECONODATA_ORIGINS_REGEX };

package/src/services/tokenService.js

@@ -1,29 +1,65 @@
-const COOKIESITENAME = `${process.env.ENV == 'hml' ? 'hml-' : ''}ecdt_token_site`
-
-function devMktTokenSanitaze(req, res, next) {
-    if(req?.headers == null) return next();
-
-    if (req.headers.authorization) {
-        req.headers.authorization = req.headers.authorization
-        .replace("+", " ")
-        .replace("%2B", " ");
-    } else if (req.headers.cookie) {
-        req.headers.authorization = `${getCookieSite(
-            req.headers.cookie
-        )}`;
-    }
+const SITE_COOKIE_NAME = "ecdt_token_site";
+const HML_SITE_COOKIE_NAME = `hml-${SITE_COOKIE_NAME}`;
 
-    return next();
-}
+/**
+ * @param {object} [options]
+ * @param {string|string[]} [options.cookieName] - Nome(s) do cookie de sessão, em ordem de preferência.
+ *   Quando omitido, o nome é resolvido por requisição a partir da origem (origin > referer > host):
+ *   origens com subdomínio "hml" usam o cookie de hml, as demais usam o de produção.
+ * @returns middleware do express
+ */
+function devMktTokenSanitaze({ cookieName } = {}) {
+    const fixedCookieNames = cookieName
+        ? (Array.isArray(cookieName) ? cookieName : [cookieName])
+        : null;
+
+    return function devMktTokenSanitazeMiddleware(req, _res, next) {
+        if (req?.headers == null) return next();
 
-function getCookieSite(cookie){ 
-    let cookies = cookie.split(';');
-    for (let index = 0; index < cookies.length; index++) {
-        if(cookies[index].includes(COOKIESITENAME)){
-            return cookies[index].split('=')[1].replace('+',' ').replace('%2B',' ')
+        if (req.headers.authorization) {
+            req.headers.authorization = req.headers.authorization
+                .replace("+", " ")
+                .replace("%2B", " ");
+        } else if (req.headers.cookie) {
+            const cookieNames = fixedCookieNames ?? resolveCookieNamesByRequest(req);
+            req.headers.authorization = getCookieValue(req.headers.cookie, cookieNames);
         }
+
+        return next();
+    };
+}
+
+function resolveCookieNamesByRequest(req) {
+    // O nome alternativo fica como fallback para o caso do cookie preferido não existir
+    return isHmlRequest(req)
+        ? [HML_SITE_COOKIE_NAME, SITE_COOKIE_NAME]
+        : [SITE_COOKIE_NAME, HML_SITE_COOKIE_NAME];
+}
+
+function isHmlRequest(req) {
+    const source = req.headers.origin ?? req.headers.referer ?? req.headers.host ?? "";
+    const hostname = String(source).replace(/^[a-z]+:\/\//i, "").split(/[/:?#]/)[0];
+    // "hml" como parte do hostname delimitado por ponto ou hífen
+    // (ex: hml.econodata.com.br, api.hml.econodata.com.br, hml-site.econodata.com.br)
+    return /(^|[.-])hml([.-]|$)/i.test(hostname);
+}
+
+function getCookieValue(cookieHeader, cookieNames) {
+    const cookies = cookieHeader.split(";").map((entry) => {
+        const separatorIndex = entry.indexOf("=");
+        if (separatorIndex === -1) return { name: entry.trim(), value: "" };
+        return {
+            name: entry.slice(0, separatorIndex).trim(),
+            value: entry.slice(separatorIndex + 1).trim(),
+        };
+    });
+
+    for (const name of cookieNames) {
+        const found = cookies.find((c) => c.name === name);
+        if (found) return found.value.replace("+", " ").replace("%2B", " ");
     }
-    return '';
+
+    return "";
 }
 
-module.exports = {devMktTokenSanitaze}
+module.exports = { devMktTokenSanitaze, SITE_COOKIE_NAME, HML_SITE_COOKIE_NAME };