@hed-hog/core 0.0.399 → 0.0.401

package/src/redis/redis-master.spec.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+import { Logger } from '@nestjs/common';
+
+const createClient = jest.fn();
+jest.mock('redis', () => ({ createClient }));
+
+// Importado depois do mock: `redis-master` resolve `createClient` no topo.
+const { isReadOnlyReplicaError, resolveMasterUrl } = require('./redis-master');
+
+const makeProbe = (info: string) => {
+  const probe = {
+    on: jest.fn(),
+    connect: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    info: jest.fn<() => Promise<string>>().mockResolvedValue(info),
+    quit: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+  };
+  createClient.mockReturnValue(probe);
+  return probe;
+};
+
+const logger = new Logger('test');
+const REPLICA_INFO = [
+  'role:slave',
+  'master_host:redis-hub-node-1.redis-hub-headless.hcode.svc.cluster.local',
+  'master_port:6379',
+  'master_link_status:up',
+].join('\r\n');
+
+describe('resolveMasterUrl', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(logger, 'warn').mockImplementation(() => undefined);
+    jest.spyOn(logger, 'log').mockImplementation(() => undefined);
+  });
+
+  it('redireciona para o master quando a URL caiu numa replica', async () => {
+    // O Service redis-hub tem os dois pods como endpoint, entao a URL do env
+    // aponta para o master metade das vezes e para a replica na outra metade.
+    makeProbe(REPLICA_INFO);
+
+    const url = await resolveMasterUrl(
+      'redis://:senha@redis-hub:6379/0',
+      logger,
+      3000,
+    );
+
+    expect(url).toBe(
+      'redis://:senha@redis-hub-node-1.redis-hub-headless.hcode.svc.cluster.local:6379/0',
+    );
+  });
+
+  it('mantem a URL quando ja caiu no master', async () => {
+    makeProbe('role:master\r\nconnected_slaves:1');
+
+    const url = await resolveMasterUrl('redis://redis-hub:6379/0', logger, 3000);
+
+    expect(url).toBe('redis://redis-hub:6379/0');
+  });
+
+  it('mantem a URL quando o probe falha, em vez de derrubar o boot', async () => {
+    createClient.mockReturnValue({
+      on: jest.fn(),
+      connect: jest
+        .fn<() => Promise<void>>()
+        .mockRejectedValue(new Error('ECONNREFUSED')),
+      info: jest.fn(),
+      quit: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    });
+
+    const url = await resolveMasterUrl('redis://redis-hub:6379/0', logger, 3000);
+
+    expect(url).toBe('redis://redis-hub:6379/0');
+  });
+
+  it('mantem a URL quando a replica nao informa o master', async () => {
+    makeProbe('role:slave\r\nmaster_link_status:down');
+
+    const url = await resolveMasterUrl('redis://redis-hub:6379/0', logger, 3000);
+
+    expect(url).toBe('redis://redis-hub:6379/0');
+  });
+
+  it('fecha o probe mesmo no caminho feliz', async () => {
+    const probe = makeProbe('role:master');
+
+    await resolveMasterUrl('redis://redis-hub:6379/0', logger, 3000);
+
+    expect(probe.quit).toHaveBeenCalled();
+  });
+
+  it('nao tenta descobrir nada sem URL', async () => {
+    const url = await resolveMasterUrl('', logger, 3000);
+
+    expect(url).toBe('');
+    expect(createClient).not.toHaveBeenCalled();
+  });
+});
+
+describe('isReadOnlyReplicaError', () => {
+  it('reconhece a recusa de escrita da replica', () => {
+    expect(
+      isReadOnlyReplicaError(
+        new Error("READONLY You can't write against a read only replica."),
+      ),
+    ).toBe(true);
+  });
+
+  it('nao confunde com outros erros', () => {
+    expect(isReadOnlyReplicaError(new Error('ECONNRESET'))).toBe(false);
+  });
+});

package/src/redis/redis-master.ts

@@ -0,0 +1,86 @@
+import { Logger } from '@nestjs/common';
+import { createClient, type RedisClientType } from 'redis';
+import { extractRedisErrorMessage, withConnectTimeout } from './redis-pubsub';
+
+/**
+ * Descobre qual nó do Redis é o master e devolve a URL dele.
+ *
+ * O `REDIS_URL` aponta para o Service `redis-hub`, e esse Service — o chart
+ * Bitnami em modo Sentinel — tem os DOIS pods como endpoint. Cada conexão nova
+ * faz round-robin entre master e réplica, então metade delas cai na réplica e
+ * toda escrita falha com `READONLY You can't write against a read only
+ * replica`. Não é falha intermitente do Redis: é o cliente conectando no nó
+ * errado.
+ *
+ * A descoberta não usa o protocolo do Sentinel de propósito. Um `INFO
+ * replication` já responde `role:` e, quando é réplica, `master_host` e
+ * `master_port` — que aqui é o DNS do headless service, resolvível de dentro do
+ * cluster. Isso dispensa configurar nome de master e porta de Sentinel, e
+ * continua valendo depois de um failover, porque a resposta é sempre a do nó
+ * que está no ar naquele momento.
+ *
+ * **Nunca lança.** Se o probe falhar, devolve a URL original: o comportamento
+ * passa a ser o de hoje, não pior.
+ */
+export async function resolveMasterUrl(
+  url: string,
+  logger: Logger,
+  connectTimeoutMs: number,
+): Promise<string> {
+  if (!url) return url;
+
+  let probe: RedisClientType | null = null;
+  try {
+    probe = createClient({
+      url,
+      // Uma tentativa só: este client existe para perguntar quem é o master, e
+      // insistir aqui atrasaria o boot sem melhorar a resposta.
+      socket: { reconnectStrategy: false },
+    }) as RedisClientType;
+    probe.on('error', () => {
+      // Tratado pelo catch; sem listener o node-redis derruba o processo.
+    });
+
+    await withConnectTimeout(probe.connect(), connectTimeoutMs);
+    const info = String(await probe.info('replication'));
+
+    if (/^role:master/m.test(info)) return url;
+
+    const host = info.match(/^master_host:(.+)$/m)?.[1]?.trim();
+    const port = info.match(/^master_port:(\d+)$/m)?.[1]?.trim();
+    if (!host || !port) {
+      logger.warn(
+        'Redis conectou numa réplica mas o INFO não trouxe master_host/master_port; seguindo com a URL original.',
+      );
+      return url;
+    }
+
+    const masterUrl = new URL(url);
+    masterUrl.hostname = host;
+    masterUrl.port = port;
+    logger.log(`Redis: conectado numa réplica, redirecionando para o master ${host}:${port}.`);
+    return masterUrl.toString();
+  } catch (error) {
+    logger.warn(
+      `Redis: não foi possível descobrir o master (${extractRedisErrorMessage(error)}); seguindo com a URL original.`,
+    );
+    return url;
+  } finally {
+    if (probe) {
+      try {
+        await probe.quit();
+      } catch {
+        // O probe já cumpriu seu papel.
+      }
+    }
+  }
+}
+
+/**
+ * `READONLY` é a resposta do Redis a uma escrita numa réplica. Distinguir esse
+ * erro dos demais é o que permite reagir a um failover reconectando, em vez de
+ * só registrar o erro e perder a escrita.
+ */
+export function isReadOnlyReplicaError(error: unknown): boolean {
+  return /READONLY/i.test(extractRedisErrorMessage(error));
+}

package/src/redis/redis-pubsub.ts

@@ -41,7 +41,7 @@ const INERT: RedisPubSub = {
  * `createClient` rejects with an `AggregateError` whose own `message` is empty,
  * so logging it directly yields "Redis error: " with nothing after it.
  */
-function extractRedisErrorMessage(error: unknown): string {
+export function extractRedisErrorMessage(error: unknown): string {
   if (error instanceof AggregateError && error.errors?.length) {
     return error.errors
       .map((e) => (e instanceof Error ? e.message || e.toString() : String(e)))
@@ -53,6 +53,29 @@ function extractRedisErrorMessage(error: unknown): string {
   return String(error);
 }
 
+/**
+ * `reconnectStrategy` never returning `false` makes `client.connect()` retry
+ * forever while Redis is down: the promise never settles, so an `await` on it
+ * inside `onModuleInit` hangs the whole app's boot. This bounds only the
+ * initial attempt; reconnection of an already-connected client stays infinite.
+ */
+export async function withConnectTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T> {
+  let timer: NodeJS.Timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`Redis connection timed out after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer!);
+  }
+}
+
 async function safeClose(client: RedisClientType | null) {
   if (!client || !client.isOpen) {
     return;
@@ -92,6 +115,7 @@ export async function createRedisPubSub(
     1000,
     Number(options.errorLogCooldownMs || DEFAULT_ERROR_LOG_COOLDOWN_MS),
   );
+  const connectTimeoutMs = Math.max(1000, Number(process.env.REDIS_CONNECT_TIMEOUT_MS || 3000));
   // A Redis outage fires `error` on every reconnect attempt; unthrottled that
   // buries every other log line in the pod.
   const lastErrorLogAt: Record<'subscriber' | 'publisher', number> = {
@@ -127,8 +151,8 @@ export async function createRedisPubSub(
     subscriber.on('error', (error) => logClientError('subscriber', error));
     publisher.on('error', (error) => logClientError('publisher', error));
 
-    await subscriber.connect();
-    await publisher.connect();
+    await withConnectTimeout(subscriber.connect(), connectTimeoutMs);
+    await withConnectTimeout(publisher.connect(), connectTimeoutMs);
     await subscriber.subscribe(channel, async (message) => {
       try {
         await onMessage(message);

package/src/redis/redis.module.ts

@@ -0,0 +1,17 @@
+import { Global, Module } from '@nestjs/common';
+import { RedisKvService } from './redis-kv.service';
+
+/**
+ * Estado efêmero compartilhado entre as réplicas da API.
+ *
+ * `@Global` porque a conexão é um recurso de processo: cada módulo que
+ * importasse este abriria seu próprio client para o mesmo Redis, e com 4
+ * réplicas isso multiplica conexões sem ganho nenhum. Mesmo motivo de o
+ * `RealtimeService` ser um só.
+ */
+@Global()
+@Module({
+  providers: [RedisKvService],
+  exports: [RedisKvService],
+})
+export class RedisModule {}

package/src/session/session.service.spec.ts

@@ -41,6 +41,22 @@ const makeDeps = () => {
   return { prisma, security, setting, token, http, user, paginationService };
 };
 
+/** Sessão viva, no formato exato que o `select` do refresh devolve. */
+const liveSession = (overrides: Record<string, unknown> = {}) => ({
+  id: 1,
+  user_id: 5,
+  ip_address: '9.9.9.9',
+  user_agent: 'old-ua',
+  revoked_at: null,
+  expires_at: new Date(Date.now() + 100000),
+  browser_id: 'br',
+  // O refresh e fail-closed: `impersonator_user_id` precisa vir do select e ser
+  // explicitamente null para a rotacao seguir.
+  impersonator_user_id: null,
+  hash: 'hash(atual)',
+  ...overrides,
+});
+
 const makeService = (deps = makeDeps()) => ({
   service: new SessionService(
     deps.prisma as any,
@@ -258,60 +274,123 @@ describe('SessionService', () => {
       ).rejects.toThrow(UnauthorizedException);
     });
 
-    it('lança Unauthorized em corrida (updateResult.count === 0)', async () => {
+    it('lança Unauthorized quando perde o CAS em todas as tentativas', async () => {
       const { service, deps } = makeService();
-      deps.prisma.user_session.findFirst.mockResolvedValue({
-        id: 1,
-        user_id: 5,
-        ip_address: '9.9.9.9',
-        user_agent: 'old-ua',
-        revoked_at: null,
-        expires_at: new Date(Date.now() + 100000),
-        browser_id: 'br',
-      });
-      const tx = {
-        user_session: {
-          updateMany: jest.fn().mockResolvedValue({ count: 0 }),
-          create: jest.fn().mockResolvedValue({ id: 2 }),
-        },
-      };
-      deps.prisma.$transaction.mockImplementation(async (cb: any) => cb(tx));
+      deps.prisma.user_session.findFirst.mockResolvedValue(liveSession());
+      deps.prisma.user_session.updateMany.mockResolvedValue({ count: 0 });
 
       await expect(
         service.refresh('en', 'tok', '1.2.3.4', 'ua'),
       ).rejects.toThrow(UnauthorizedException);
     });
 
-    it('rotaciona sessão e usa fallback de ip/ua quando vazios', async () => {
+    // A regressao que motivou a rotacao estavel: o perdedor de uma corrida
+    // levava 401, e no cliente 401 no /auth/refresh e logout.
+    it('não desloga quando perde o CAS e ganha na segunda tentativa', async () => {
       const { service, deps } = makeService();
-      deps.prisma.user_session.findFirst.mockResolvedValue({
-        id: 1,
-        user_id: 5,
-        ip_address: '9.9.9.9',
-        user_agent: 'old-ua',
-        revoked_at: null,
-        expires_at: new Date(Date.now() + 100000),
-        browser_id: 'br',
-        // O refresh e fail-closed: `impersonator_user_id` precisa vir do select
-        // e ser explicitamente null para a rotacao seguir.
-        impersonator_user_id: null,
-      });
-      const tx = {
-        user_session: {
-          updateMany: jest.fn().mockResolvedValue({ count: 1 }),
-          create: jest.fn().mockResolvedValue({ id: 2 }),
-        },
-      };
-      deps.prisma.$transaction.mockImplementation(async (cb: any) => cb(tx));
+      deps.prisma.user_session.findFirst
+        .mockResolvedValueOnce(liveSession({ hash: 'hash(velho)' }))
+        .mockResolvedValueOnce(liveSession({ hash: 'hash(girado)' }));
+      deps.prisma.user_session.updateMany
+        .mockResolvedValueOnce({ count: 0 })
+        .mockResolvedValueOnce({ count: 1 });
+
+      const result = await service.refresh('en', 'tok', '1.2.3.4', 'ua');
+
+      expect(result.token).toBe('opaque');
+      expect(result.session.id).toBe(1);
+      expect(deps.prisma.user_session.updateMany).toHaveBeenCalledTimes(2);
+    });
+
+    it('rotaciona na MESMA linha e usa fallback de ip/ua quando vazios', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue(liveSession());
+      deps.prisma.user_session.updateMany.mockResolvedValue({ count: 1 });
 
       const result = await service.refresh('en', 'tok', '   ', '');
 
       expect(result.token).toBe('opaque');
-      expect(result.session).toEqual({ id: 2 });
-      const createArg = tx.user_session.create.mock.calls[0][0];
-      expect(createArg.data.ip_address).toBe('9.9.9.9');
-      expect(createArg.data.user_agent).toBe('old-ua');
-      expect(createArg.data.browser_id).toBe('br');
+      // O `sessionId` do JWT sai daqui: se ele mudasse, todo access token em voo
+      // morreria na hora em TokenService.verify — a cascata que deslogava o aluno.
+      expect(result.session.id).toBe(1);
+      expect(deps.prisma.user_session.create).not.toHaveBeenCalled();
+
+      const updateArg: any = deps.prisma.user_session.updateMany.mock.calls[0][0];
+      expect(updateArg.where.id).toBe(1);
+      // Compare-and-swap: sem o hash no `where`, duas rotacoes simultaneas
+      // passariam as duas.
+      expect(updateArg.where.hash).toBe('hash(atual)');
+      expect(updateArg.data.hash).toBe('hash(opaque)');
+      expect(updateArg.data.previous_hash).toBe('hash(atual)');
+      expect(updateArg.data.ip_address).toBe('9.9.9.9');
+      expect(updateArg.data.user_agent).toBe('old-ua');
+      expect(updateArg.data.browser_id).toBe('br');
+      expect(updateArg.data.revoked_at).toBeUndefined();
+    });
+
+    it('abre a janela de graça para o hash anterior', async () => {
+      jest.useFakeTimers().setSystemTime(new Date('2026-08-24T12:00:00Z'));
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue(liveSession());
+      deps.prisma.user_session.updateMany.mockResolvedValue({ count: 1 });
+
+      await service.refresh('en', 'tok', '1.2.3.4', 'ua');
+
+      const updateArg: any = deps.prisma.user_session.updateMany.mock.calls[0][0];
+      expect(updateArg.data.previous_hash_expires_at.getTime()).toBe(
+        Date.parse('2026-08-24T12:00:00Z') + 30_000,
+      );
+
+      // E a busca precisa aceitar esse hash anterior, senao a janela nao serve
+      // para nada: e ela que salva a sessao quando a resposta do refresh se perde.
+      const findArg: any = deps.prisma.user_session.findFirst.mock.calls[0][0];
+      expect(findArg.where.OR).toEqual([
+        { hash: 'hash(tok)' },
+        {
+          previous_hash: 'hash(tok)',
+          previous_hash_expires_at: { gt: expect.any(Date) },
+        },
+      ]);
+    });
+
+    it('renovar não despeja o próprio slot pelo limite de sessões', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'max-concurrent-sessions': 1,
+      });
+      deps.prisma.user_session.findFirst.mockResolvedValue(liveSession());
+      deps.prisma.user_session.updateMany.mockResolvedValue({ count: 1 });
+      // Dois slots vivos com o limite em 1: sem a protecao, o mais antigo — que
+      // e justamente o que esta renovando — seria revogado, e o usuario voltaria
+      // para o /login no proximo request.
+      deps.prisma.user_session.findMany.mockResolvedValue([
+        { id: 1, browser_id: 'br' },
+        { id: 9, browser_id: 'outro' },
+      ]);
+
+      await service.refresh('en', 'tok', '1.2.3.4', 'ua', 'br');
+
+      const revokeCall = deps.prisma.user_session.updateMany.mock.calls.find(
+        (call: any) => call[0]?.data?.revoked_at instanceof Date,
+      ) as any;
+      expect(revokeCall[0].where.id.in).toEqual([9]);
+    });
+  });
+
+  describe('deleteRefreshTokenCookie', () => {
+    it('aceita o hash anterior dentro da janela de graça', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue({ user_id: 5 });
+      deps.prisma.user_session.updateMany.mockResolvedValue({ count: 1 });
+
+      const result = await service.deleteRefreshTokenCookie({}, 'tok');
+
+      expect(result).toEqual({ count: 1, userId: 5 });
+      // Sair da conta com um token que acabou de girar tem de derrubar a sessao
+      // de verdade, e nao responder sucesso deixando-a viva.
+      const updateArg: any = deps.prisma.user_session.updateMany.mock.calls[0][0];
+      expect(updateArg.where.revoked_at).toBeNull();
+      expect(updateArg.where.OR[1].previous_hash).toBe('hash(tok)');
     });
   });