@ecdt/server-common 1.7.0 → 2.0.0

package/test/motorAvaliadorService.test.js

@@ -0,0 +1,222 @@
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+    avaliarGatilhos,
+    pontuar,
+    casaPublico,
+    normalizarPorte,
+    horarioComercial,
+} = require('../src/services/motorAvaliadorService.js');
+
+// Fonte de leitura dublada. Sem os cinco metodos a avaliacao recusa a chamada, entao o dublê
+// declara todos e o teste sobrescreve o que interessa.
+const fonteDe = (respostas = {}) => ({
+    levantouMaoRecentemente: async () => respostas.levantouMao ?? null,
+    contagemAgrupada: async () => respostas.contagem ?? { total: 0 },
+    contagemDeTipos: async () => respostas.contagem ?? { total: 0 },
+    ultimoDisparo: async () => respostas.ultimoDisparo ?? undefined,
+    contagensNaJanela: async () => respostas.contagens ?? [],
+});
+
+const EVENTO = {
+    eventoId: 'e1',
+    tipo: 'desbloqueou_empresa',
+    idUsuario: 1,
+    // Terca-feira, 14h BRT: dentro do horario comercial e fora de feriado.
+    dtEvento: new Date('2026-09-22T17:00:00.000Z'),
+    payload: { setor: 'farmacias' },
+};
+
+const PERFIL = { temConta: true, cargo: null, porte: null };
+
+const catalogoCom = (gatilhos, tipos = { desbloqueou_empresa: { peso: 10 } }) => ({
+    tipos,
+    acoes: { acao_x: { canal: 'n8n', ativo: true, params: {} } },
+    gatilhos,
+    janelaEmDias: 30,
+});
+
+const gatilho = (extra) => ({
+    nome: 'g',
+    disparo: 'imediato',
+    condicao: { tipos: ['desbloqueou_empresa'] },
+    acoes: [{ acao: 'acao_x' }],
+    cooldownH: null,
+    ...extra,
+});
+
+describe('a fonte e contrato, nao sugestao', () => {
+    test('fonte sem um dos cinco metodos e recusada, dizendo qual falta', async () => {
+        const incompleta = { ...fonteDe() };
+        delete incompleta.contagensNaJanela;
+        await assert.rejects(
+            () => avaliarGatilhos(EVENTO, catalogoCom([gatilho()]), PERFIL, null, incompleta),
+            /fonte sem os métodos contagensNaJanela/
+        );
+    });
+
+    test('fonte ausente tambem e recusada, e nao estoura no meio da avaliacao', async () => {
+        await assert.rejects(
+            () => avaliarGatilhos(EVENTO, catalogoCom([gatilho()]), PERFIL, null, undefined),
+            /fonte sem os métodos/
+        );
+    });
+});
+
+describe('catalogo e casos de borda', () => {
+    test('catalogo vazio nao dispara e nao lanca', async () => {
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([]), PERFIL, null, fonteDe());
+        assert.deepEqual(r, { disparos: [], recusas: [] });
+    });
+
+    test('tipo fora do catalogo nao fecha o imediato', async () => {
+        const catalogo = catalogoCom([gatilho()], {});
+        const r = await avaliarGatilhos(EVENTO, catalogo, PERFIL, null, fonteDe());
+        assert.equal(r.disparos.length, 0);
+        assert.match(r.recusas[0].motivo, /condição não fechou/);
+    });
+
+    test('contagem com janela invalida recusa com motivo, sem consultar', async () => {
+        const g = gatilho({ disparo: 'contagem', condicao: { tipos: ['desbloqueou_empresa'], quantidade: 2, janela: 'semana' } });
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([g]), PERFIL, null, fonteDe());
+        assert.equal(r.recusas[0].motivo, 'janela inválida no cadastro');
+    });
+
+    test('agrupamento sem o campo no payload recusa dizendo qual campo', async () => {
+        const g = gatilho({
+            disparo: 'contagem',
+            condicao: { tipos: ['desbloqueou_empresa'], quantidade: 2, janela: '7d', agrupar_por: 'payload.regiao' },
+        });
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([g]), PERFIL, null, fonteDe());
+        assert.equal(r.recusas[0].motivo, 'evento sem o campo regiao do agrupamento');
+    });
+
+    test('pontuacao sem pesos no gatilho cai no peso do catalogo', async () => {
+        const g = gatilho({ disparo: 'pontuacao', condicao: { limiar: 30 } });
+        const fonte = fonteDe({ contagens: [{ tipo: 'desbloqueou_empresa', total: '3' }] });
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([g]), PERFIL, null, fonte);
+        assert.equal(r.disparos.length, 1);
+        assert.equal(r.disparos[0].contexto.pontuacao, 30);
+    });
+});
+
+describe('as tres formas de disparo', () => {
+    test('imediato fecha com o tipo no catalogo', async () => {
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([gatilho()]), PERFIL, null, fonteDe());
+        assert.equal(r.disparos.length, 1);
+        assert.equal(r.disparos[0].contexto.evento, 'desbloqueou_empresa');
+    });
+
+    test('contagem fecha no limite e nao abaixo', async () => {
+        const g = gatilho({ disparo: 'contagem', condicao: { tipos: ['desbloqueou_empresa'], quantidade: 3, janela: '24h' } });
+        const abaixo = await avaliarGatilhos(EVENTO, catalogoCom([g]), PERFIL, null, fonteDe({ contagem: { total: '2' } }));
+        assert.equal(abaixo.disparos.length, 0);
+        const noLimite = await avaliarGatilhos(EVENTO, catalogoCom([g]), PERFIL, null, fonteDe({ contagem: { total: '3' } }));
+        assert.equal(noLimite.disparos.length, 1);
+        assert.equal(noLimite.disparos[0].contexto.contagem, 3);
+    });
+
+    test('o disparo NAO carrega identificador: a identidade e do chamador', async () => {
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([gatilho()]), PERFIL, null, fonteDe());
+        assert.deepEqual(Object.keys(r.disparos[0]).sort(), ['contexto', 'gatilho']);
+    });
+});
+
+describe('gates', () => {
+    test('horario comercial barra fora da janela e a pontuacao segue contando', async () => {
+        const g = gatilho({ condicao: { tipos: ['desbloqueou_empresa'], horario_comercial: true } });
+        const domingo = { ...EVENTO, dtEvento: new Date('2026-09-20T17:00:00.000Z') };
+        const r = await avaliarGatilhos(domingo, catalogoCom([g]), PERFIL, null, fonteDe());
+        assert.match(r.recusas[0].motivo, /horário comercial: fim de semana/);
+    });
+
+    test('intervalo entre disparos barra dentro da janela', async () => {
+        const g = gatilho({ cooldownH: 24 });
+        const fonte = fonteDe({ ultimoDisparo: { dt_gatilho: new Date('2026-09-22T10:00:00.000Z') } });
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([g]), PERFIL, null, fonte);
+        assert.match(r.recusas[0].motivo, /em intervalo de 24h/);
+    });
+
+    test('sem ultimo disparo, o intervalo nao barra — e o caso da simulacao', async () => {
+        const g = gatilho({ cooldownH: 24 });
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([g]), PERFIL, null, fonteDe());
+        assert.equal(r.disparos.length, 1);
+    });
+
+    test('gate pos-levantada so consulta quando ha acao in_page e e-mail', async () => {
+        let consultas = 0;
+        const fonte = { ...fonteDe(), levantouMaoRecentemente: async () => { consultas += 1; return true; } };
+        const catalogo = catalogoCom([gatilho()]);
+        catalogo.acoes.acao_x.canal = 'in_page';
+        const comEmail = await avaliarGatilhos(EVENTO, catalogo, PERFIL, 'a@b.c', fonte);
+        assert.equal(consultas, 1);
+        assert.match(comEmail.recusas[0].motivo, /levantou a mão/);
+        await avaliarGatilhos(EVENTO, catalogo, PERFIL, null, fonte);
+        assert.equal(consultas, 1, 'sem e-mail nao consulta');
+    });
+});
+
+describe('A24 — o mais especifico vence', () => {
+    test('o preterido aparece como preterido, dizendo por quem perdeu', async () => {
+        const geral = gatilho({ nome: 'geral', disparo: 'pontuacao', condicao: { limiar: 10 } });
+        const especifico = gatilho({
+            nome: 'especifico', disparo: 'pontuacao',
+            condicao: { limiar: 10, publico: { com_conta: true } },
+        });
+        const fonte = fonteDe({ contagens: [{ tipo: 'desbloqueou_empresa', total: '3' }] });
+        const r = await avaliarGatilhos(EVENTO, catalogoCom([geral, especifico]), PERFIL, null, fonte);
+        assert.equal(r.disparos.length, 1);
+        assert.equal(r.disparos[0].gatilho.nome, 'especifico');
+        assert.deepEqual(r.disparos[0].contexto.gatilhos_preteridos, ['geral']);
+    });
+
+    test('empate de especificidade desempata por nome, e e deterministico', async () => {
+        const a = gatilho({ nome: 'aaa', disparo: 'pontuacao', condicao: { limiar: 10 } });
+        const b = gatilho({ nome: 'bbb', disparo: 'pontuacao', condicao: { limiar: 10 } });
+        const fonte = fonteDe({ contagens: [{ tipo: 'desbloqueou_empresa', total: '3' }] });
+        for (const ordem of [[a, b], [b, a]]) {
+            const r = await avaliarGatilhos(EVENTO, catalogoCom(ordem), PERFIL, null, fonte);
+            assert.equal(r.disparos[0].gatilho.nome, 'aaa');
+        }
+    });
+});
+
+describe('as funcoes puras que o avaliador usa', () => {
+    test('bucket agrupa antes de pontuar, e o resto e descartado', () => {
+        const tipos = { lista: { peso: 25, bucket: 3 } };
+        assert.equal(pontuar({ lista: 2 }, tipos).total, 0);
+        assert.equal(pontuar({ lista: 3 }, tipos).total, 25);
+        assert.equal(pontuar({ lista: 5 }, tipos).total, 25);
+        assert.equal(pontuar({ lista: 6 }, tipos).total, 50);
+    });
+
+    test('peso do gatilho sobrescreve o do catalogo (A25)', () => {
+        assert.equal(pontuar({ a: 1 }, { a: { peso: 5 } }, { a: 50 }).total, 50);
+    });
+
+    test('porte legado com zero a esquerda casa a faixa canonica', () => {
+        assert.equal(normalizarPorte('01-04'), '1-4');
+        assert.equal(normalizarPorte('acima de 500'), 'Mais que 500');
+        assert.equal(normalizarPorte('sei la'), '', 'irreconhecivel volta vazio, nao a primeira faixa');
+    });
+
+    test('publico sem criterio e fallback com especificidade zero', () => {
+        assert.deepEqual(casaPublico(undefined, PERFIL), {
+            casa: true, especificidade: 0, motivo: 'sem criterio (fallback)'.replace('criterio', 'critério'),
+        });
+    });
+
+    test('plano premium nao casa ninguem na v1, e o motivo diz por que', () => {
+        const r = casaPublico({ plano: ['premium'] }, PERFIL);
+        assert.equal(r.casa, false);
+        assert.match(r.motivo, /usuário do site é gratuito/);
+    });
+
+    test('feriado nacional fecha a janela mesmo em dia util', () => {
+        // 7 de setembro de 2026 e uma segunda-feira.
+        assert.deepEqual(horarioComercial(new Date('2026-09-07T17:00:00.000Z')), {
+            dentro: false, motivo: 'feriado nacional',
+        });
+    });
+});

package/src/services/cookieService.js

@@ -1,43 +0,0 @@
-const TAMANHO_MAXIMO_PADRAO = 100;
-
-function sanitizarId(valor, maxLen = TAMANHO_MAXIMO_PADRAO) {
-    if (typeof valor !== "string") return null;
-
-    const limpo = valor.trim();
-    return limpo ? limpo.slice(0, maxLen) : null;
-}
-
-function lerCookie(cabecalho, nome) {
-    if (typeof cabecalho !== "string" || typeof nome !== "string") return null;
-
-    for (const parte of cabecalho.split(";")) {
-        const separador = parte.indexOf("=");
-        if (separador === -1) continue;
-        if (parte.slice(0, separador).trim() !== nome) continue;
-        return parte.slice(separador + 1).trim();
-    }
-
-    return null;
-}
-
-function idDoCookie(cabecalho, nome, { maxLen = TAMANHO_MAXIMO_PADRAO } = {}) {
-    const bruto = lerCookie(cabecalho, nome);
-    if (!bruto) return null;
-
-    let valor = bruto;
-    try {
-        valor = decodeURIComponent(bruto);
-    } catch (_erroDeEncoding) {
-        valor = bruto;
-    }
-
-    try {
-        const conteudo = JSON.parse(valor);
-        const id = conteudo && typeof conteudo === "object" ? conteudo.id : conteudo;
-        return sanitizarId(typeof id === "string" ? id : String(id ?? ""), maxLen);
-    } catch (_naoEhJson) {
-        return sanitizarId(valor, maxLen);
-    }
-}
-
-module.exports = { lerCookie, idDoCookie, sanitizarId };

package/src/services/motorEventosService.js

@@ -1,103 +0,0 @@
-const { idDoCookie, sanitizarId } = require("./cookieService.js");
-
-const TIMEOUT_PADRAO_MS = 2000;
-
-function urlConfigurada(url) {
-    const configurada = url ?? process.env.MOTOR_EVENTOS_URL;
-
-    if (typeof configurada !== "string" || configurada.trim() === "") {
-        console.warn("motorEventos: url do coletor ausente, evento nao publicado");
-        return null;
-    }
-
-    return configurada.trim();
-}
-
-function textoNaoVazio(valor) {
-    return typeof valor === "string" && valor.trim() !== "" ? valor.trim() : null;
-}
-
-function publicarEvento({
-    tipo,
-    autorizacao,
-    idVisitante,
-    payload,
-    url,
-    timeoutMs = TIMEOUT_PADRAO_MS,
-    aoFalhar = (mensagem) => console.error(mensagem),
-} = {}) {
-    try {
-        const destino = urlConfigurada(url);
-        const visitante = textoNaoVazio(idVisitante);
-
-        if (!destino || !tipo || (!autorizacao && !visitante)) {
-            return;
-        }
-
-        const cabecalhos = { "Content-Type": "application/json" };
-        if (autorizacao) {
-            cabecalhos.Authorization = autorizacao;
-        }
-
-        const corpo = {
-            tipo,
-            dt_evento: new Date().toISOString(),
-            payload: payload ?? {},
-        };
-        if (visitante) {
-            corpo.id_visitante = visitante;
-        }
-
-        fetch(destino, {
-            method: "POST",
-            headers: cabecalhos,
-            body: JSON.stringify(corpo),
-            signal: AbortSignal.timeout(timeoutMs),
-        })
-            .then((resposta) => {
-                if (!resposta.ok) {
-                    aoFalhar(`motorEventos: ${tipo} recusado com status ${resposta.status}`);
-                }
-            })
-            .catch((erro) => {
-                aoFalhar(`motorEventos: ${tipo} nao publicado (${erro?.message})`);
-            });
-    } catch (erro) {
-        try {
-            aoFalhar(`motorEventos: ${tipo} nao publicado (${erro?.message})`);
-        } catch (_erroNoCallback) {
-            /* empty */
-        }
-    }
-}
-
-/**
- * Publica o evento a partir da requisicao que o gerou: tira o token do header
- * Authorization e o identificador anonimo do corpo ou do cookie, nessa ordem.
- * Nunca lanca, nem quando `req` nao tem headers nem corpo — o evento e
- * secundario ao fluxo, e boa parte das chamadas acontece depois de uma escrita
- * ja efetivada.
- */
-function publicarEventoDaRequisicao(req, {
-    tipo,
-    payload,
-    cookieVisitante = process.env.MOTOR_EVENTOS_COOKIE_VISITANTE,
-    ...resto
-} = {}) {
-    try {
-        const doCorpo = sanitizarId(req?.body?.id_visitante);
-        const doCookie = cookieVisitante ? idDoCookie(req?.headers?.cookie, cookieVisitante) : null;
-
-        publicarEvento({
-            tipo,
-            payload,
-            autorizacao: req?.headers?.authorization,
-            idVisitante: doCorpo ?? doCookie,
-            ...resto,
-        });
-    } catch (erro) {
-        console.error(`motorEventos: ${tipo} nao publicado (${erro?.message})`);
-    }
-}
-
-module.exports = { publicarEvento, publicarEventoDaRequisicao };

package/test/cookieService.test.js

@@ -1,59 +0,0 @@
-const { test, describe } = require('node:test');
-const assert = require('node:assert/strict');
-
-const { lerCookie, idDoCookie, sanitizarId } = require('../src/services/cookieService.js');
-
-const comCookie = (nome, valor) => `_ga=GA1.1.9; ${nome}=${encodeURIComponent(valor)}; outro=x`;
-
-describe('sanitizarId', () => {
-    test('devolve null para vazio, espaco em branco ou valor que nao e string', () => {
-        assert.equal(sanitizarId(''), null);
-        assert.equal(sanitizarId('   '), null);
-        assert.equal(sanitizarId(undefined), null);
-        assert.equal(sanitizarId(42), null);
-    });
-
-    test('corta no tamanho maximo', () => {
-        assert.equal(sanitizarId('a'.repeat(300)).length, 100);
-        assert.equal(sanitizarId('a'.repeat(300), 10).length, 10);
-    });
-});
-
-describe('lerCookie', () => {
-    test('acha o cookie no meio do header', () => {
-        assert.equal(lerCookie('a=1; alvo=valor; b=2', 'alvo'), 'valor');
-    });
-
-    test('nao casa com cookie de nome parecido', () => {
-        assert.equal(lerCookie('alvo_antigo=valor', 'alvo'), null);
-    });
-
-    test('devolve null sem header, sem o cookie ou com header que nao e string', () => {
-        assert.equal(lerCookie(undefined, 'alvo'), null);
-        assert.equal(lerCookie('a=1', 'alvo'), null);
-        assert.equal(lerCookie({}, 'alvo'), null);
-        assert.equal(lerCookie('a=1', undefined), null);
-    });
-});
-
-describe('idDoCookie', () => {
-    test('extrai o id quando o cookie guarda JSON', () => {
-        assert.equal(idDoCookie(comCookie('trk', '{"id":"visitante-1"}'), 'trk'), 'visitante-1');
-    });
-
-    test('aceita o cookie como string simples', () => {
-        assert.equal(idDoCookie(comCookie('trk', 'visitante-2'), 'trk'), 'visitante-2');
-    });
-
-    test('devolve null quando o JSON nao tem id', () => {
-        assert.equal(idDoCookie(comCookie('trk', '{"outro":"x"}'), 'trk'), null);
-    });
-
-    test('devolve null quando o cookie nao existe', () => {
-        assert.equal(idDoCookie('a=1', 'trk'), null);
-    });
-
-    test('respeita o maxLen', () => {
-        assert.equal(idDoCookie(comCookie('trk', 'a'.repeat(300)), 'trk', { maxLen: 5 }).length, 5);
-    });
-});