@hed-hog/core 0.0.399 → 0.0.401

package/src/setting/favicon.controller.ts

@@ -0,0 +1,135 @@
+import { Public } from '@hed-hog/api';
+import { Controller, Get, Logger, NotFoundException, Res } from '@nestjs/common';
+import { Response } from 'express';
+import { BrandAssetService } from './brand-asset.service';
+import { SettingService } from './setting.service';
+
+/** Timeout do fetch da imagem configurada. */
+const FETCH_TIMEOUT_MS = 5_000;
+
+/** Quanto tempo o binario baixado fica em memoria antes de buscar de novo. */
+const CACHE_TTL_MS = 10 * 60_000;
+
+type CachedIcon = {
+  url: string;
+  body: Buffer;
+  contentType: string;
+  expiresAt: number;
+};
+
+/**
+ * `GET /favicon.ico` no host da API, com o icone do Branding (`icon-url`).
+ *
+ * Quem procura o favicon no dominio da API sao os clientes que so conhecem esse
+ * endereco - o conector MCP no claude.ai, por exemplo, mostra o icone do dominio
+ * do servidor ao lado do nome. Sem esta rota a resposta era o 404 JSON do Nest e
+ * o conector caia na letra inicial.
+ *
+ * O arquivo e servido daqui (e nao por redirect) porque nem todo coletor de
+ * favicon segue redirecionamento. O Content-Type e o da origem, entao um SVG
+ * configurado no Branding chega como SVG.
+ */
+@Controller()
+export class FaviconController {
+  private readonly logger = new Logger(FaviconController.name);
+  private cache: CachedIcon | null = null;
+
+  constructor(
+    private readonly setting: SettingService,
+    private readonly brandAsset: BrandAssetService,
+  ) {}
+
+  @Public()
+  @Get('favicon.ico')
+  async favicon(@Res() res: Response) {
+    const icon = await this.loadIcon();
+
+    if (!icon) {
+      throw new NotFoundException();
+    }
+
+    res.setHeader('Content-Type', icon.contentType);
+    res.setHeader('Cache-Control', 'public, max-age=3600');
+    res.send(icon.body);
+  }
+
+  private async loadIcon(): Promise<CachedIcon | null> {
+    const settings = await this.setting.getSettingValues([
+      'icon-url',
+      'image-url',
+    ]);
+    const value =
+      String(settings['icon-url'] ?? '').trim() ||
+      String(settings['image-url'] ?? '').trim();
+    const url = await this.brandAsset.resolveAssetUrl(value);
+
+    if (!url) {
+      return null;
+    }
+
+    if (
+      this.cache &&
+      this.cache.url === url &&
+      this.cache.expiresAt > Date.now()
+    ) {
+      return this.cache;
+    }
+
+    const icon = await this.download(url);
+
+    if (icon) {
+      this.cache = icon;
+      return icon;
+    }
+
+    // Origem fora do ar: melhor o icone anterior do que nenhum.
+    return this.cache?.url === url ? this.cache : null;
+  }
+
+  private async download(url: string): Promise<CachedIcon | null> {
+    const dataUri = /^data:([^;,]+)(;base64)?,([\s\S]*)$/i.exec(url);
+
+    if (dataUri) {
+      const [, contentType, base64, payload] = dataUri;
+      return {
+        url,
+        contentType,
+        body: base64
+          ? Buffer.from(payload, 'base64')
+          : Buffer.from(decodeURIComponent(payload)),
+        expiresAt: Date.now() + CACHE_TTL_MS,
+      };
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+      const response = await globalThis
+        .fetch(url, { signal: controller.signal })
+        .finally(() => clearTimeout(timeout));
+
+      const contentType = response.headers.get('content-type') ?? '';
+
+      if (!response.ok || !contentType.startsWith('image/')) {
+        this.logger.warn(
+          `Favicon source ${url} answered ${response.status} ${contentType || '(no content-type)'}`,
+        );
+        return null;
+      }
+
+      return {
+        url,
+        contentType,
+        body: Buffer.from(await response.arrayBuffer()),
+        expiresAt: Date.now() + CACHE_TTL_MS,
+      };
+    } catch (error) {
+      this.logger.warn(
+        `Could not fetch favicon source ${url}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+      return null;
+    }
+  }
+}

package/src/setting/setting.module.ts

@@ -5,6 +5,7 @@ import { Global, Module, forwardRef } from '@nestjs/common';
 import { AuthModule } from '../auth/auth.module';
 import { MailModule } from '../mail/mail.module';
 import { BrandAssetService } from './brand-asset.service';
+import { FaviconController } from './favicon.controller';
 import { SettingsController } from './setting.controller';
 import { SettingService } from './setting.service';
 
@@ -17,7 +18,7 @@ import { SettingService } from './setting.service';
     forwardRef(() => LocaleModule),
     forwardRef(() => MailModule),
   ],
-  controllers: [SettingsController],
+  controllers: [SettingsController, FaviconController],
   providers: [SettingService, BrandAssetService],
   exports: [SettingService, BrandAssetService],
 })

package/src/setting/setting.service.ts

@@ -67,6 +67,15 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
   );
   private lastRedisSubscriberErrorLogAt = 0;
   private lastRedisPublisherErrorLogAt = 0;
+  // A `reconnectStrategy` que nunca devolve `false` faz `client.connect()` ficar
+  // retentando pra sempre quando o Redis está indisponível: a Promise nunca
+  // resolve nem rejeita, e `onModuleInit` trava o boot inteiro da API esperando
+  // por ela. Este teto bound só a tentativa inicial; a reconexão de um cliente
+  // já conectado continua indefinida.
+  private readonly redisConnectTimeoutMs = Math.max(
+    1000,
+    Number(process.env.REDIS_CONNECT_TIMEOUT_MS || 3000),
+  );
 
   constructor(
     @Inject(forwardRef(() => PrismaService))
@@ -140,6 +149,23 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
     return String(error);
   }
 
+  private async 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!);
+    }
+  }
+
   private async initializeRedisSync() {
     if (!this.redisUrl) {
       this.logger.log(
@@ -169,8 +195,8 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
         this.logRedisClientError('publisher', error);
       });
 
-      await this.redisSubscriber.connect();
-      await this.redisPublisher.connect();
+      await this.withConnectTimeout(this.redisSubscriber.connect(), this.redisConnectTimeoutMs);
+      await this.withConnectTimeout(this.redisPublisher.connect(), this.redisConnectTimeoutMs);
       await this.redisSubscriber.subscribe(this.redisChannel, async (message) => {
         await this.handleRedisSettingsVersionMessage(message);
       });
@@ -529,7 +555,22 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
       'lms-video-frame-capture-interval-seconds',
       'lms-error-modal-enabled',
       'url',
-      'app-urls'
+      'app-urls',
+      // Hcode Store: liga/desliga a venda no frontend (o backend também
+      // recusa o checkout — isto é só para a UI mostrar "Em breve" cedo).
+      'commerce-store-sales-enabled',
+      // A loja lê esta para decidir se dispara o beacon de navegação. A irmã
+      // `-persist` NÃO entra aqui de propósito: é decisão de servidor (grava ou
+      // não IP e origem) e não tem por que chegar ao navegador.
+      'commerce-store-visitor-tracking',
+      // A partir de quantas unidades a loja mostra "Última unidade"/"Restam N".
+      // Só afeta o aviso na vitrine — a trava de quantidade é do backend e não
+      // depende deste valor chegar ao navegador.
+      'commerce-store-low-stock-threshold',
+      // Se a loja abre o stream de estoque ao vivo. Desligada, o frontend nem
+      // conecta — que é o ponto: sem isto aqui, cada visitante abriria uma
+      // conexão de longa duração para um recurso que está fora de uso.
+      'commerce-store-realtime-stock-enabled'
     ];
     const setting = await this.getSettingValues(slugs);
     return { locales, setting };

package/src/task/task.service.spec.ts

@@ -44,4 +44,45 @@ describe('TasksService', () => {
       expect(values).toContain(500);
     });
   });
+
+  describe('clearOldAccessLogs', () => {
+    it('repete lotes ate drenar o acumulo', async () => {
+      // O bug: um unico lote por execucao diaria contra uma ingestao uma ordem
+      // de grandeza maior deixava a retencao inalcancavel.
+      const { service, deps } = makeService();
+      deps.settingService.getSettingValues.mockResolvedValue({
+        'cleanup-batch-limit': 100,
+      });
+      deps.prismaService.$executeRaw
+        .mockResolvedValueOnce(100)
+        .mockResolvedValueOnce(100)
+        .mockResolvedValueOnce(42);
+
+      await (service as any).clearOldAccessLogs();
+
+      expect(deps.prismaService.$executeRaw).toHaveBeenCalledTimes(3);
+    });
+
+    it('para no primeiro lote incompleto', async () => {
+      const { service, deps } = makeService();
+      deps.settingService.getSettingValues.mockResolvedValue({
+        'cleanup-batch-limit': 100,
+      });
+      deps.prismaService.$executeRaw.mockResolvedValue(0);
+
+      await (service as any).clearOldAccessLogs();
+
+      expect(deps.prismaService.$executeRaw).toHaveBeenCalledTimes(1);
+    });
+
+    it('usa os defaults de retencao e de lote quando as settings faltam', async () => {
+      const { service, deps } = makeService();
+      deps.settingService.getSettingValues.mockResolvedValue({});
+
+      await (service as any).clearOldAccessLogs();
+
+      const values = deps.prismaService.$executeRaw.mock.calls[0].slice(1);
+      expect(values).toContain(20000);
+    });
+  });
 });

package/src/task/task.service.ts

@@ -3,6 +3,13 @@ import { Injectable, Logger } from '@nestjs/common';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { SettingService } from '../setting/setting.service';
 
+/**
+ * Teto de tempo da limpeza do `access_log`. Existe para o caso da entrada
+ * superar a saída de novo: o laço para e devolve o resto para a execução
+ * seguinte, em vez de varrer a madrugada inteira disputando o banco.
+ */
+const ACCESS_LOG_CLEANUP_BUDGET_MS = 10 * 60 * 1000;
+
 @Injectable()
 export class TasksService {
   private readonly logger = new Logger(TasksService.name);
@@ -270,6 +277,23 @@ export class TasksService {
     );
   }
 
+  /**
+   * Apaga os logs de acesso fora da janela de `access-log-retention-days`.
+   *
+   * Roda em lotes até drenar, e não em um lote só. O `access_log` recebe um
+   * INSERT por requisição — em produção, de 200 a 540 mil por dia — enquanto a
+   * limpeza apagava `cleanup-batch-limit` registros por execução diária. Com a
+   * entrada uma ordem de grandeza acima da saída, a retenção nunca era
+   * alcançada: a tabela chegou a 18,6 milhões de linhas e 4 GB, com 11,8
+   * milhões já vencidos e registros três meses mais velhos que a retenção de 30
+   * dias configurada.
+   *
+   * O `cleanup-batch-limit` passa a ser o tamanho de CADA lote — o papel que a
+   * própria descrição da setting sempre anunciou ("valores menores evitam locks
+   * prolongados mas aumentam a duração da limpeza"). O teto agora é de tempo,
+   * não de linhas: o laço para ao drenar a fila ou ao estourar o orçamento,
+   * para que a limpeza não avance madrugada adentro competindo com o tráfego.
+   */
   private async clearOldAccessLogs(): Promise<void> {
     const settings = await this.settingService.getSettingValues([
       'cleanup-batch-limit',
@@ -280,21 +304,37 @@ export class TasksService {
     this.logger.verbose('Starting cleanup of old access logs');
     const startAt = Date.now();
 
-    await this.prismaService.$executeRaw`
-      WITH del AS (
-        SELECT id
-        FROM access_log
-        WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
-        ORDER BY id
-        LIMIT ${batchLimit}
-      )
-      DELETE FROM access_log al
-      USING del
-      WHERE al.id = del.id
-    `;
+    let deleted = 0;
+    let batches = 0;
+    for (;;) {
+      const removed = await this.prismaService.$executeRaw`
+        WITH del AS (
+          SELECT id
+          FROM access_log
+          WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
+          ORDER BY id
+          LIMIT ${batchLimit}
+        )
+        DELETE FROM access_log al
+        USING del
+        WHERE al.id = del.id
+      `;
+
+      deleted += removed;
+      batches += 1;
+
+      if (removed < batchLimit) break;
+
+      if (Date.now() - startAt >= ACCESS_LOG_CLEANUP_BUDGET_MS) {
+        this.logger.warn(
+          `Access log cleanup hit the ${ACCESS_LOG_CLEANUP_BUDGET_MS}ms budget after ${deleted} rows; the remainder goes on the next run.`,
+        );
+        break;
+      }
+    }
 
     this.logger.verbose(
-      `Old access logs cleaned up in ${Date.now() - startAt}ms`,
+      `Old access logs cleaned up in ${Date.now() - startAt}ms (${deleted} rows in ${batches} batches)`,
     );
   }
 

package/src/token/token.service.spec.ts

@@ -410,4 +410,94 @@ describe('TokenService', () => {
       );
     });
   });
+
+  describe('verify - audiencia (audience binding)', () => {
+    const RESOURCE = 'https://hub-api.example.com/mcp';
+    const activeSession = {
+      revoked_at: null,
+      expires_at: new Date(Date.now() + 60_000),
+    };
+
+    // ESTE e o teste central do audience binding: sem ele, o token entregue ao
+    // conector do Claude valeria na API REST inteira.
+    it('recusa token COM aud numa rota que nao declara recurso', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({ sub: 1, sessionId: 9, aud: RESOURCE });
+
+      await expect(service.verify('en', 'tok')).rejects.toThrow(
+        UnauthorizedException,
+      );
+      // Nem chega a consultar a sessao: a recusa e antes.
+      expect(deps.prisma.user_session.findUnique).not.toHaveBeenCalled();
+    });
+
+    it('recusa token cujo aud e de OUTRO recurso', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({
+        sub: 1,
+        sessionId: 9,
+        aud: 'https://outro.example.com/mcp',
+      });
+
+      await expect(service.verify('en', 'tok', RESOURCE)).rejects.toThrow(
+        UnauthorizedException,
+      );
+    });
+
+    it('aceita token cujo aud casa exatamente com o recurso', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({ sub: 1, sessionId: 9, aud: RESOURCE });
+      deps.prisma.user_session.findUnique.mockResolvedValue(activeSession);
+
+      await expect(service.verify('en', 'tok', RESOURCE)).resolves.toMatchObject({
+        sub: 1,
+        aud: RESOURCE,
+      });
+    });
+
+    // Comparacao por igualdade exata: barra final e outro recurso.
+    it('nao normaliza barra final ao comparar', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({
+        sub: 1,
+        sessionId: 9,
+        aud: RESOURCE + '/',
+      });
+
+      await expect(service.verify('en', 'tok', RESOURCE)).rejects.toThrow(
+        UnauthorizedException,
+      );
+    });
+
+    // O login normal nao pode mudar de comportamento por causa disso.
+    it('aceita token SEM aud, com ou sem recurso declarado', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({ sub: 1, sessionId: 9 });
+      deps.prisma.user_session.findUnique.mockResolvedValue(activeSession);
+
+      await expect(service.verify('en', 'tok')).resolves.toMatchObject({ sub: 1 });
+      await expect(service.verify('en', 'tok', RESOURCE)).resolves.toMatchObject({
+        sub: 1,
+      });
+    });
+
+    it('falha fechado em erro de banco quando o token e de recurso', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({ sub: 1, sessionId: 9, aud: RESOURCE });
+      deps.prisma.user_session.findUnique.mockRejectedValue(new Error('db down'));
+
+      await expect(service.verify('en', 'tok', RESOURCE)).rejects.toThrow(
+        UnauthorizedException,
+      );
+    });
+
+    it('segue aberto em erro de banco para a sessao de login', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({ sub: 1, sessionId: 9 });
+      deps.prisma.user_session.findUnique.mockRejectedValue(new Error('db down'));
+
+      await expect(service.verify('en', 'tok')).resolves.toMatchObject({ sub: 1 });
+    });
+  });
+
 });

package/src/token/token.service.ts

@@ -22,13 +22,46 @@ export class TokenService {
     private readonly setting: SettingService,
   ) { }
 
-  async verify(locale: string, token: string) {
+  /**
+   * `allowedAudience` declara qual recurso ESTA rota atende. A regra e de mao
+   * unica, e e essa assimetria que faz o modelo funcionar:
+   *
+   * - token SEM `aud` (o login normal) vale em qualquer lugar, com ou sem o
+   *   parametro — nada muda para quem ja existe;
+   * - token COM `aud` so vale onde aquele exato recurso foi declarado. Em
+   *   qualquer outra rota, 401.
+   *
+   * O AuthGuard global chama este metodo SEM o terceiro argumento, entao toda
+   * rota que ninguem marcou como recurso ja recusa um token de conector — por
+   * construcao, inclusive nas rotas que ainda nem foram escritas. Nao ha
+   * allowlist para alguem esquecer de atualizar.
+   *
+   * A comparacao e feita aqui, na mao, e nao pela opcao `audience` do
+   * jsonwebtoken: quando aquela opcao esta ausente, a lib simplesmente NAO OLHA o
+   * claim. E exatamente essa omissao que precisa virar rejeicao.
+   */
+  async verify(locale: string, token: string, allowedAudience?: string) {
     try {
 
       const payload = await this.jwt.verifyAsync(token, {
         secret: this.security.getJwtSecret(),
       });
 
+      const audience = payload.aud;
+      const isResourceToken = audience !== undefined;
+
+      // Igualdade exata de string, sem parsear URL — normalizar abriria as mesmas
+      // brechas que a allowlist de redirect_uri ja evita (barra final, case do
+      // host, porta default).
+      if (isResourceToken && audience !== allowedAudience) {
+        this.logger.warn(
+          `[TokenVerify] sessionId=${payload.sessionId} userId=${payload.sub} token with aud=${audience} used outside its resource`,
+        );
+        throw new UnauthorizedException(
+          getLocaleText('accessDenied', locale, 'Access denied.'),
+        );
+      }
+
       // Verify session is not revoked (only if prisma is available)
       if (payload.sessionId && this.prisma) {
         try {
@@ -62,8 +95,21 @@ export class TokenService {
           if (sessionError instanceof UnauthorizedException) {
             throw sessionError;
           }
-          // DB error: log but allow auth to continue to avoid blocking on transient DB issues
           this.logger.error(`[TokenVerify] DB error validating sessionId=${payload.sessionId} userId=${payload.sub}: ${(sessionError as any)?.message}`);
+
+          // Token de recurso nao ganha o beneficio da duvida. Para a sessao de
+          // login, seguir em frente numa falha transitoria de banco e a troca
+          // certa — derrubar todo mundo logado e pior que aceitar uma revogacao
+          // com atraso. Para um token entregue a um cliente externo, user_session
+          // e o UNICO jeito de revogar: continuar aqui faria uma revogacao valer
+          // so no vencimento do JWT. A decisao segue a natureza do TOKEN, nao a
+          // da rota.
+          if (isResourceToken) {
+            throw new UnauthorizedException(
+              getLocaleText('accessDenied', locale, 'Access denied.'),
+            );
+          }
+          // DB error: log but allow auth to continue to avoid blocking on transient DB issues
         }
       }
 

package/src/user/user-credential.util.ts

@@ -21,15 +21,24 @@ export function hasPendingPasswordReset(user: any): boolean {
   );
 }
 
+/**
+ * Credencial de senha que ainda vale: do tipo password e não revogada.
+ *
+ * Existe para quem já tem as credenciais em memória e precisa do mesmo critério
+ * que as consultas de Prisma expressam com `revoked_at: null`. O login e a troca
+ * de e-mail filtravam só por `type`, então uma credencial revogada continuava
+ * autenticando — e a revogação é justamente o que o convite de acesso enterprise
+ * usa para transformar "autorize o acesso" em "crie sua conta e defina a senha".
+ */
+export function isActivePasswordCredential(credential: any): boolean {
+  return credential?.type === 'password' && !credential?.revoked_at;
+}
+
 /**
  * Usuários criados/autenticados apenas via provedor externo (ex: Microsoft
  * Entra ID) nunca têm uma credencial de senha ativa — não faz sentido
  * oferecer o fluxo de "esqueci a senha" para eles.
  */
 export function hasPasswordCredential(user: any): boolean {
-  return Boolean(
-    user?.user_credential?.some(
-      (credential) => credential?.type === 'password' && !credential?.revoked_at,
-    ),
-  );
+  return Boolean(user?.user_credential?.some(isActivePasswordCredential));
 }

package/src/user/user.service.ts

@@ -25,6 +25,7 @@ import {
   PENDING_PASSWORD_RESET_WHERE,
   hasPendingPasswordReset,
 } from './user-credential.util';
+import { USER_SORT } from './user.sort';
 
 // Constants
 const IDENTIFIER_TYPE = {
@@ -48,17 +49,6 @@ const PASSWORD_CHARSETS = {
   symbols: '@#$%&*!?-_+',
 } as const;
 
-const USER_SORT_FIELDS = [
-  'id',
-  'name',
-  'photo_id',
-  'suspended_until',
-  'suspended_reason',
-  'deactivated_at',
-  'created_at',
-  'updated_at',
-] as const;
-
 type UserChangeLog = user_change_log;
 type UserChangeLogActor = Prisma.userGetPayload<{
   select: {
@@ -164,7 +154,7 @@ export class UserService {
       this.prismaService.user,
       {
         ...paginationParams,
-        validSortFields: USER_SORT_FIELDS,
+        sort: USER_SORT,
         where: this.buildUserListWhere(filter, paginationParams?.search),
         include: this.getUserIncludeClause(),
       }

package/src/user/user.sort.ts

@@ -0,0 +1,25 @@
+import { defineSortable } from '@hed-hog/api-pagination';
+
+/**
+ * Campos ordenáveis de `user`.
+ *
+ * `email` fica de fora: mora em `user_identifier` (relação to-many filtrada
+ * por `type = 'email'`), sem coluna própria em `user` para o Prisma ordenar —
+ * mesma limitação documentada em `libraries/lms/src/instructor/instructor.sort.ts`
+ * para o e-mail do instrutor.
+ *
+ * `passwordReset` também fica de fora: é booleano calculado no service
+ * (`hasPendingPasswordReset`), não uma coluna.
+ *
+ * Sem ninguém pedir ordenação, o resultado continua igual ao de antes
+ * (`id` desc, o fallback do `paginatePrismaModel` quando não há `sortField`).
+ */
+export const USER_SORT = defineSortable(
+  {
+    name: true,
+    suspended_until: true,
+    last_login_at: true,
+    id: { initialOrder: 'desc' },
+  },
+  { default: 'id', defaultOrder: 'desc' },
+);

package/src/utils/abbreviate-name.spec.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from '@jest/globals';
+import { abbreviateName } from './abbreviate-name';
+
+describe('abbreviateName', () => {
+  it('mantém primeiro nome e último sobrenome', () => {
+    expect(abbreviateName('João Henrique Cunha Rangel')).toBe('João Rangel');
+  });
+
+  it('ignora partículas (de/da/do/das/dos/e) ao escolher o último sobrenome', () => {
+    expect(abbreviateName('Maria de Souza')).toBe('Maria Souza');
+    expect(abbreviateName('Ana da Silva')).toBe('Ana Silva');
+    expect(abbreviateName('Pedro dos Santos')).toBe('Pedro Santos');
+    expect(abbreviateName('Carlos do Nascimento')).toBe('Carlos Nascimento');
+    expect(abbreviateName('José das Neves')).toBe('José Neves');
+    expect(abbreviateName('Silva e Souza Junior')).toBe('Silva Junior');
+  });
+
+  it('nome com duas palavras não muda', () => {
+    expect(abbreviateName('Ana Paula')).toBe('Ana Paula');
+  });
+
+  it('nome com uma palavra só passa como está', () => {
+    expect(abbreviateName('Madonna')).toBe('Madonna');
+  });
+
+  it('nome vazio ou só espaço devolve vazio', () => {
+    expect(abbreviateName('')).toBe('');
+    expect(abbreviateName('   ')).toBe('');
+  });
+
+  it('nome nulo/indefinido devolve vazio', () => {
+    expect(abbreviateName(null)).toBe('');
+    expect(abbreviateName(undefined)).toBe('');
+  });
+
+  it('normaliza espaços múltiplos entre palavras', () => {
+    expect(abbreviateName('  João   Henrique   Rangel  ')).toBe('João Rangel');
+  });
+
+  it('cai no primeiro nome quando só sobra partícula depois dele', () => {
+    // Dado maltratado (ex.: sobrenome vazio salvo como "de") — não deve
+    // repetir o primeiro nome nem devolver a partícula sozinha.
+    expect(abbreviateName('João de')).toBe('João');
+  });
+
+  it('fallback "Alguém"/"Someone" (sem atribuidor) passa direto, sem quebrar', () => {
+    expect(abbreviateName('Alguém')).toBe('Alguém');
+    expect(abbreviateName('Someone')).toBe('Someone');
+  });
+});