@hed-hog/core 0.0.387 → 0.0.393

package/src/setting/setting.service.spec.ts

@@ -7,6 +7,7 @@ import {
   jest,
 } from '@jest/globals';
 import { BadRequestException } from '@nestjs/common';
+import { localeStorage } from '@hed-hog/api-locale';
 import { SettingService } from './setting.service';
 
 const makeDeps = () => {
@@ -16,7 +17,7 @@ const makeDeps = () => {
       findFirst: jest.fn(),
       findUnique: jest.fn(),
     },
-    setting_user: { findMany: jest.fn() },
+    setting_user: { findMany: jest.fn(), findFirst: jest.fn() },
     user: { findUnique: jest.fn() },
     $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
     $queryRawUnsafe: jest.fn().mockResolvedValue([]),
@@ -236,6 +237,62 @@ describe('SettingService', () => {
     });
   });
 
+  describe('ensureCacheVersionFresh', () => {
+    // Rajadas de leitura (ex.: lote de uploads de segmentos HLS) chegavam juntas antes de
+    // `lastSettingsVersionCheckAt` avançar e cada uma abria sua própria dupla de queries,
+    // ocupando o pool de conexões inteiro durante a conversão de vídeo.
+    it('deduplica checagens simultâneas em uma única ida ao banco', async () => {
+      const { service, deps } = makeService();
+      let resolveQuery: (rows: unknown[]) => void = () => {};
+      const pendingQuery = new Promise<unknown[]>((resolve) => {
+        resolveQuery = resolve;
+      });
+      deps.prisma.$queryRawUnsafe.mockReturnValue(pendingQuery);
+
+      const checks = Promise.all(
+        Array.from({ length: 5 }, () => (service as any).ensureCacheVersionFresh()),
+      );
+      resolveQuery([{ version: 1 }]);
+      await checks;
+
+      expect(deps.prisma.$queryRawUnsafe).toHaveBeenCalledTimes(1);
+    });
+
+    it('garante a linha de estado uma vez só, não a cada checagem', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.$queryRawUnsafe.mockResolvedValue([{ version: 1 }]);
+      jest.useFakeTimers();
+
+      await (service as any).ensureCacheVersionFresh();
+      jest.advanceTimersByTime(60_000);
+      await (service as any).ensureCacheVersionFresh();
+
+      expect(deps.prisma.$queryRawUnsafe).toHaveBeenCalledTimes(2);
+      expect(deps.prisma.$executeRawUnsafe).toHaveBeenCalledTimes(1);
+    });
+
+    it('limpa o cache quando a versão do banco avança', async () => {
+      const { service, deps } = makeService();
+      service.setCache({ flag: true });
+      deps.prisma.$queryRawUnsafe.mockResolvedValue([{ version: 9 }]);
+
+      await (service as any).ensureCacheVersionFresh();
+
+      expect((service as any).cachedSettings).toEqual({});
+      expect((service as any).localSettingsVersion).toBe(9);
+    });
+
+    it('libera o dedup mesmo quando a checagem falha', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.$queryRawUnsafe.mockRejectedValueOnce(new Error('too many clients'));
+
+      await expect((service as any).ensureCacheVersionFresh()).rejects.toThrow(
+        'too many clients',
+      );
+      expect((service as any).settingsVersionCheckInFlight).toBeNull();
+    });
+  });
+
   describe('getEffectiveSettings', () => {
     it('coage overrides do usuário conforme tipo global', async () => {
       const { service } = makeService();
@@ -313,4 +370,81 @@ describe('SettingService', () => {
       ).resolves.toBeUndefined();
     });
   });
+
+  // Cadeia única de idioma do sistema: e-mail transacional e aviso de idioma de
+  // curso precisam responder a mesma pergunta do mesmo jeito.
+  describe('resolveUserLocale', () => {
+    const arrange = (deps: any, opts: { override?: string | null; system?: string } = {}) => {
+      deps.prisma.setting_user.findFirst.mockResolvedValue(
+        opts.override ? { value: opts.override } : null,
+      );
+      deps.prisma.setting.findMany.mockResolvedValue([
+        { id: 1, slug: 'language', value: opts.system ?? 'en', type: 'string', user_override: true },
+      ]);
+    };
+
+    it('a preferência do usuário vence tudo', async () => {
+      const { service, deps } = makeService();
+      arrange(deps, { override: 'pt', system: 'en' });
+
+      const result = await localeStorage.run({ locale: 'en', detected: true }, () =>
+        service.resolveUserLocale(42),
+      );
+
+      expect(result).toBe('pt');
+    });
+
+    it('normaliza a preferência gravada com região', async () => {
+      const { service, deps } = makeService();
+      arrange(deps, { override: 'pt-BR' });
+
+      await expect(service.resolveUserLocale(42)).resolves.toBe('pt');
+    });
+
+    it('sem preferência, usa o idioma que o cliente declarou', async () => {
+      const { service, deps } = makeService();
+      arrange(deps, { system: 'en' });
+
+      const result = await localeStorage.run({ locale: 'pt', detected: true }, () =>
+        service.resolveUserLocale(42),
+      );
+
+      expect(result).toBe('pt');
+    });
+
+    // O `en` default do middleware não pode passar por escolha do cliente e
+    // atropelar a setting do sistema.
+    it('ignora o locale do contexto quando o cliente não declarou idioma', async () => {
+      const { service, deps } = makeService();
+      arrange(deps, { system: 'pt' });
+
+      const result = await localeStorage.run({ locale: 'en', detected: false }, () =>
+        service.resolveUserLocale(42),
+      );
+
+      expect(result).toBe('pt');
+    });
+
+    it('cai na setting do sistema fora de qualquer requisição', async () => {
+      const { service, deps } = makeService();
+      arrange(deps, { system: 'pt' });
+
+      await expect(service.resolveUserLocale(42)).resolves.toBe('pt');
+    });
+
+    it('funciona sem usuário (destinatário que não tem conta)', async () => {
+      const { service, deps } = makeService();
+      arrange(deps, { system: 'pt' });
+
+      await expect(service.resolveUserLocale(null)).resolves.toBe('pt');
+      expect(deps.prisma.setting_user.findFirst).not.toHaveBeenCalled();
+    });
+
+    it('cai em "en" quando a consulta falha', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting_user.findFirst.mockRejectedValue(new Error('db down'));
+
+      await expect(service.resolveUserLocale(42)).resolves.toBe('en');
+    });
+  });
 });

package/src/setting/setting.service.ts

@@ -1,5 +1,11 @@
 import { itemTranslations } from '@hed-hog/api';
-import { getLocaleText, LocaleService } from '@hed-hog/api-locale';
+import {
+  getLocaleFromContext,
+  getLocaleText,
+  isLocaleDetectedFromContext,
+  LocaleService,
+  normalizeLocaleCode,
+} from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService, setting_type_0f055cd5ea_enum } from '@hed-hog/api-prisma';
 import {
@@ -51,6 +57,8 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
   );
   private localSettingsVersion = 0;
   private lastSettingsVersionCheckAt = 0;
+  private settingsVersionCheckInFlight: Promise<void> | null = null;
+  private settingsVersionStateEnsured = false;
   private redisPublisher: RedisClientType | null = null;
   private redisSubscriber: RedisClientType | null = null;
   private readonly redisErrorLogCooldownMs = Math.max(
@@ -208,11 +216,18 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
   }
 
   private async ensureSettingsVersionState() {
+    // A linha é criada uma vez e nunca some; repetir o INSERT a cada checagem de versão
+    // dobrava as queries de um caminho que roda a cada 5s em todo processo.
+    if (this.settingsVersionStateEnsured) {
+      return;
+    }
+
     await this.prismaService.$executeRawUnsafe(`
       INSERT INTO "setting_runtime_state" ("scope", "version", "updated_at")
       VALUES ('global', 0, NOW())
       ON CONFLICT ("scope") DO NOTHING
     `);
+    this.settingsVersionStateEnsured = true;
   }
 
   private parseVersionValue(value: unknown): number {
@@ -272,8 +287,23 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
       return;
     }
 
+    // `lastSettingsVersionCheckAt` só avança depois do await, então uma rajada de leituras
+    // paralelas (ex.: lote de uploads de segmentos HLS) disparava a mesma dupla de queries
+    // uma vez por chamada e ocupava o pool inteiro. Todas passam a esperar a mesma checagem.
+    if (this.settingsVersionCheckInFlight) {
+      return this.settingsVersionCheckInFlight;
+    }
+
+    this.settingsVersionCheckInFlight = this.runSettingsVersionCheck(now).finally(() => {
+      this.settingsVersionCheckInFlight = null;
+    });
+
+    return this.settingsVersionCheckInFlight;
+  }
+
+  private async runSettingsVersionCheck(startedAt: number) {
     const currentVersion = await this.getSettingsVersionFromDatabase();
-    this.lastSettingsVersionCheckAt = now;
+    this.lastSettingsVersionCheckAt = startedAt;
 
     if (currentVersion > this.localSettingsVersion) {
       this.localSettingsVersion = currentVersion;
@@ -471,12 +501,17 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
       'password-min-numbers',
       'password-min-uppercase',
       'password-min-length',
+      'password-max-age-days',
+      'password-block-leaked',
       'mfa-email-code-length',
       'mcp-enabled',
+      'richtext-ai-enabled',
+      'richtext-ai-profile-id',
       'date-format',
       'time-format',
       'timezone',
       'menu-width',
+      'pagination-page-sizes',
       'maintenance-mode-enabled',
       'providers',
       'oauth-facebook-enabled',
@@ -489,6 +524,7 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
       'disable-authentication-with-email-and-password',
       'contact-allow-company-registration',
       'operations.comment-edit-window',
+      'vaults.auto-lock-seconds',
       'lms-video-conversion-enabled',
       'lms-video-frame-capture-interval-seconds',
       'lms-error-modal-enabled',
@@ -1275,6 +1311,106 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
     });
   }
 
+  /**
+   * Le SO o override do usuario, sem cair para o valor global.
+   *
+   * `getSettingValues(slug, userId)` nao serve para isso: quando o usuario nao
+   * tem override ele devolve o valor global, indistinguivel de uma preferencia
+   * real. Quem precisa saber se o usuario *escolheu* algo - o idioma do e-mail
+   * e a gravacao unica no login - depende dessa diferenca.
+   */
+  async getUserSettingValue(
+    userId: number,
+    slug: string,
+  ): Promise<string | null> {
+    if (!userId) {
+      return null;
+    }
+
+    const settingUser = await this.prismaService.setting_user.findFirst({
+      where: {
+        user_id: userId,
+        setting: {
+          slug,
+          user_override: true,
+        },
+      },
+      select: {
+        value: true,
+      },
+    });
+
+    const value = String(settingUser?.value ?? '').trim();
+
+    return value || null;
+  }
+
+  /**
+   * Idioma efetivo de um usuario.
+   *
+   * Cadeia unica do sistema, para que e-mail, aviso de idioma de curso e
+   * qualquer outra decisao de idioma respondam a mesma pergunta do mesmo jeito:
+   *
+   *   1. preferencia gravada do usuario  - escolha explicita sempre vence;
+   *   2. idioma que o cliente declarou nesta requisicao;
+   *   3. setting global `language`;
+   *   4. `en`.
+   *
+   * O passo 2 exige que o cliente tenha REALMENTE declarado: o `en` que o
+   * middleware usa como default nao pode vencer a setting do sistema.
+   */
+  async resolveUserLocale(userId?: number | null): Promise<string> {
+    try {
+      if (userId) {
+        const preferred = normalizeLocaleCode(
+          await this.getUserSettingValue(userId, 'language'),
+        );
+
+        if (preferred) {
+          return preferred;
+        }
+      }
+
+      const fromRequest = normalizeLocaleCode(getLocaleFromContext());
+
+      if (fromRequest && isLocaleDetectedFromContext()) {
+        return fromRequest;
+      }
+
+      const settings = await this.getSettingValues(['language']);
+
+      return normalizeLocaleCode(settings?.['language']) ?? fromRequest ?? 'en';
+    } catch (error) {
+      this.logger.warn(`Could not resolve locale for user ${userId}: ${error}`);
+
+      return normalizeLocaleCode(getLocaleFromContext()) ?? 'en';
+    }
+  }
+
+  /**
+   * Valores aceitos por uma setting de combobox (`setting_list`).
+   *
+   * `setSettingUserValue` valida que a setting existe e permite override, mas
+   * nao valida o *valor*. Sem esta checagem, um navegador em `de-DE` gravaria
+   * `de` como idioma e todo e-mail seguinte procuraria um template que nao
+   * existe.
+   */
+  async getSettingListValues(slug: string): Promise<string[]> {
+    const setting = await this.prismaService.setting.findFirst({
+      where: { slug },
+      select: {
+        setting_list: {
+          select: { value: true },
+          orderBy: { order: 'asc' },
+        },
+      },
+    });
+
+    return (setting?.setting_list ?? [])
+      .map((item) => String(item?.value ?? '').trim())
+      .filter(Boolean);
+  }
+
   async getSettingValues(
     slug: string | string[],
     userId?: number,

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

@@ -7,6 +7,7 @@ import {
   jest,
 } from '@jest/globals';
 import {
+  BadRequestException,
   ForbiddenException,
   UnauthorizedException,
 } from '@nestjs/common';
@@ -279,6 +280,21 @@ describe('TokenService', () => {
       );
     });
 
+    it('createAccessToken repassa expiresIn por chamada (sessão simulada)', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.signAsync.mockResolvedValue('signed');
+
+      await service.createAccessToken(
+        { sub: 42, sessionId: 555, act: 7, imp: true },
+        { expiresIn: 1800 },
+      );
+
+      expect(deps.jwt.signAsync).toHaveBeenCalledWith(
+        { sub: 42, sessionId: 555, act: 7, imp: true },
+        { secret: 'secret', expiresIn: 1800 },
+      );
+    });
+
     it('createOpaqueToken delega ao security', async () => {
       const { service, deps } = makeService();
       await expect(service.createOpaqueToken(32)).resolves.toBe('opaque-token');
@@ -328,6 +344,52 @@ describe('TokenService', () => {
       );
     });
 
+    it('createEmailConfirmationToken assina com propósito e validade de 7d', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.signAsync.mockResolvedValue('confirm-tok');
+
+      await expect(
+        service.createEmailConfirmationToken({ userIdentifierId: 42 }),
+      ).resolves.toBe('confirm-tok');
+      expect(deps.jwt.signAsync).toHaveBeenCalledWith(
+        { userIdentifierId: 42, purpose: 'email-confirmation' },
+        expect.objectContaining({ secret: 'secret', expiresIn: '7d' }),
+      );
+    });
+
+    it('verifyEmailConfirmationToken retorna o identificador do payload', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({
+        userIdentifierId: 42,
+        purpose: 'email-confirmation',
+      });
+
+      await expect(
+        service.verifyEmailConfirmationToken('pt-BR', 'tok'),
+      ).resolves.toEqual({ userIdentifierId: 42 });
+    });
+
+    // Sem esta checagem, um token de MFA ou de sessão viraria confirmação de
+    // e-mail — e, no sentido inverso, o token do link entraria em fluxos que
+    // autenticam.
+    it('verifyEmailConfirmationToken recusa token de outro propósito', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockResolvedValue({ userIdentifierId: 42 });
+
+      await expect(
+        service.verifyEmailConfirmationToken('pt-BR', 'tok'),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('verifyEmailConfirmationToken lança BadRequest em token inválido', async () => {
+      const { service, deps } = makeService();
+      deps.jwt.verifyAsync.mockRejectedValue(new Error('bad'));
+
+      await expect(
+        service.verifyEmailConfirmationToken('pt-BR', 'tok'),
+      ).rejects.toThrow(BadRequestException);
+    });
+
     it('decodeExpiredToken ignora expiração', async () => {
       const { service, deps } = makeService();
       deps.jwt.verifyAsync.mockResolvedValue({ sub: 7 });

package/src/token/token.service.ts

@@ -1,10 +1,13 @@
 import { getLocaleText } from "@hed-hog/api-locale";
 import { PrismaService } from "@hed-hog/api-prisma";
-import { ForbiddenException, forwardRef, Inject, Injectable, Logger, UnauthorizedException } from "@nestjs/common";
-import { JwtService } from "@nestjs/jwt";
+import { BadRequestException, ForbiddenException, forwardRef, Inject, Injectable, Logger, UnauthorizedException } from "@nestjs/common";
+import { JwtService, JwtSignOptions } from "@nestjs/jwt";
 import { SecurityService } from "../security/security.service";
 import { SettingService } from "../setting/setting.service";
 
+/** Claim que separa o token do link de confirmação de e-mail dos demais JWTs. */
+const EMAIL_CONFIRMATION_PURPOSE = 'email-confirmation';
+
 @Injectable()
 export class TokenService {
   private readonly logger = new Logger(TokenService.name);
@@ -79,9 +82,16 @@ export class TokenService {
     }
   }
 
-  async createAccessToken(payload: Record<string, any>) {
+  /**
+   * `options` permite sobrescrever o `expiresIn` global do JwtModule numa
+   * chamada especifica — usado pela simulacao de acesso, cujo token precisa
+   * morrer junto com a sessao (que nao e renovavel) e nao aos 15 minutos
+   * padrao.
+   */
+  async createAccessToken(payload: Record<string, any>, options?: JwtSignOptions) {
     return this.jwt.signAsync(payload, {
       secret: this.security.getJwtSecret(),
+      ...(options ?? {}),
     });
   }
 
@@ -178,6 +188,50 @@ export class TokenService {
     }
   }
 
+  /**
+   * Token do link de confirmação de e-mail enviado no cadastro. É um JWT, e não
+   * um token opaco em `user_identifier_challenge` como o do reset de senha, por
+   * dois motivos: `completeAccount`/`authorizeAccountInvite` aceitam qualquer
+   * linha válida daquela tabela, então um token gravado ali transformaria o
+   * e-mail de boas-vindas num link de login de 7 dias — o claim `purpose` fecha
+   * essa porta; e como nada é consumido, clicar duas vezes (pré-fetch do
+   * cliente de e-mail, encaminhamento) continua funcionando.
+   */
+  async createEmailConfirmationToken(payload: { userIdentifierId: number }) {
+    return this.jwt.signAsync(
+      { ...payload, purpose: EMAIL_CONFIRMATION_PURPOSE },
+      {
+        secret: this.security.getJwtSecret(),
+        expiresIn: '7d',
+      },
+    );
+  }
+
+  async verifyEmailConfirmationToken(
+    locale: string,
+    token: string,
+  ): Promise<{ userIdentifierId: number }> {
+    try {
+      const payload = await this.jwt.verifyAsync(token, {
+        secret: this.security.getJwtSecret(),
+      });
+
+      if (payload.purpose !== EMAIL_CONFIRMATION_PURPOSE) {
+        throw new Error('Token purpose mismatch');
+      }
+
+      return { userIdentifierId: payload.userIdentifierId };
+    } catch (error) {
+      throw new BadRequestException(
+        getLocaleText(
+          'confirmEmail.invalidOrExpired',
+          locale,
+          'This confirmation link is invalid or has expired.',
+        ),
+      );
+    }
+  }
+
   async decodeExpiredToken(token: string): Promise<any> {
     try {
       return await this.jwt.verifyAsync(token, {

package/src/user/dto/create-with-email-and-password.dto.ts

@@ -1,5 +1,5 @@
 import { getLocaleText } from '@hed-hog/api-locale';
-import { IsString } from 'class-validator';
+import { IsOptional, IsString } from 'class-validator';
 import { IsEmailWithSettings } from '../../validators/is-email-with-settings.validator';
 import { IsStrongPasswordWithSettings } from '../../validators/is-strong-password-with-settings.validator';
 
@@ -18,4 +18,9 @@ export class CreateWithEmailAndPasswordDTO {
 
   @IsString({ message: (args) => getLocaleText('validation.nameRequired', args.value) })
   name: string;
+
+  /** Chave do app de origem (ex.: "class"), usada para resolver o nome de marca no e-mail de confirmacao. */
+  @IsOptional()
+  @IsString()
+  app?: string;
 }

package/src/user/dto/query-user-mail-list.dto.ts

@@ -0,0 +1,10 @@
+import { PaginationDTO } from '@hed-hog/api-pagination';
+import { Transform } from 'class-transformer';
+import { IsIn, IsOptional } from 'class-validator';
+
+export class QueryUserMailListDTO extends PaginationDTO {
+  @IsOptional()
+  @Transform(({ value }) => String(value ?? '').trim().toLowerCase())
+  @IsIn(['all', 'received', 'read', 'error'])
+  status?: 'all' | 'received' | 'read' | 'error';
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Regra única de "reset de senha pendente": credencial de senha ativa
+ * (não revogada) marcada com requires_reset.
+ */
+export const PENDING_PASSWORD_RESET_WHERE = {
+  some: {
+    type: 'password',
+    requires_reset: true,
+    revoked_at: null,
+  },
+} as const;
+
+export function hasPendingPasswordReset(user: any): boolean {
+  return Boolean(
+    user?.user_credential?.some(
+      (credential) =>
+        credential?.type === 'password' &&
+        credential?.requires_reset === true &&
+        !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,
+    ),
+  );
+}

package/src/user/user.controller.ts

@@ -12,6 +12,7 @@ import {
   ParseIntPipe,
   Patch,
   Post,
+  Query,
   Req,
   Res,
   UploadedFile,
@@ -22,6 +23,7 @@ import { FileInterceptor } from '@nestjs/platform-express';
 import { Request } from 'express';
 import { DeleteDTO } from '../dto/delete.dto';
 import { CreateWithEmailAndPasswordDTO } from './dto/create-with-email-and-password.dto';
+import { QueryUserMailListDTO } from './dto/query-user-mail-list.dto';
 import { ResetPasswordDTO } from './dto/reset-password.dto';
 import { UpdateDTO } from './dto/update.dto';
 import { UserService } from './user.service';
@@ -35,8 +37,8 @@ export class UserController {
   ) { }
 
   @Get()
-  async list(@Pagination() paginationParams) {
-    return this.userService.list(paginationParams);
+  async list(@Pagination() paginationParams, @Query('filter') filter?: string) {
+    return this.userService.list(paginationParams, filter);
   }
 
   @Get(':userId')
@@ -154,6 +156,19 @@ export class UserController {
     return this.userService.listUserChangeLogs(locale, userId, paginationParams);
   }
 
+  @Get(':userId/mail')
+  async listMails(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Pagination() paginationParams,
+    @Query() query: QueryUserMailListDTO,
+    @Locale() locale: string,
+  ) {
+    return this.userService.listUserMails(locale, userId, {
+      ...paginationParams,
+      status: query.status,
+    });
+  }
+
   @Post(':userId/role/:roleId')
   async assignRoleToUser(
     @Param('userId', ParseIntPipe) userId: number,