@hed-hog/core 0.0.390 → 0.0.393

package/src/challenge/challenge.service.spec.ts

@@ -33,6 +33,7 @@ const makeDeps = () => {
   };
   const token = {
     createOpaqueToken: jest.fn().mockResolvedValue('tok'),
+    createEmailConfirmationToken: jest.fn().mockResolvedValue('confirm-tok'),
   };
   const mail = {
     sendTemplatedMail: jest.fn().mockResolvedValue(undefined),
@@ -196,6 +197,78 @@ describe('ChallengeService', () => {
     });
   });
 
+  describe('sendEmailConfirmationLink', () => {
+    const setupIdentifier = (deps: any) => {
+      deps.prisma.user_identifier.findFirst.mockResolvedValue({ id: 42 });
+      deps.prisma.user.findUnique.mockResolvedValue({ name: 'Bob' });
+      deps.setting.getSettingValues.mockResolvedValue({
+        url: 'https://admin.com',
+        'app-urls': ['training=https://train.com'],
+      });
+    };
+
+    it('envia o link de confirmação apontando para o app de origem', async () => {
+      const { service, deps } = makeService();
+      setupIdentifier(deps);
+
+      await service.sendEmailConfirmationLink('pt', 1, 'a@b.com', 'training');
+
+      expect(deps.token.createEmailConfirmationToken).toHaveBeenCalledWith({
+        userIdentifierId: 42,
+      });
+      expect(deps.mail.sendTemplatedMail).toHaveBeenCalledWith(
+        'pt',
+        expect.objectContaining({
+          email: 'a@b.com',
+          slug: 'auth-sign-up-confirm-email',
+          app: 'training',
+          variables: expect.objectContaining({
+            link: 'https://train.com/confirm-email?token=confirm-tok',
+            name: 'Bob',
+          }),
+        }),
+      );
+    });
+
+    it('não manda mais código: o e-mail de cadastro só leva o link', async () => {
+      const { service, deps } = makeService();
+      setupIdentifier(deps);
+
+      await service.sendEmailConfirmationLink('pt', 1, 'a@b.com', 'training');
+
+      const [, payload]: any = deps.mail.sendTemplatedMail.mock.calls[0];
+      expect(payload.variables.code).toBeUndefined();
+      // Sem linha em user_identifier_challenge: o token é um JWT autocontido.
+      expect(deps.prisma.user_identifier_challenge.create).not.toHaveBeenCalled();
+    });
+
+    it('cai na URL padrão quando o app não está mapeado', async () => {
+      const { service, deps } = makeService();
+      setupIdentifier(deps);
+
+      await service.sendEmailConfirmationLink('pt', 1, 'a@b.com');
+
+      expect(deps.mail.sendTemplatedMail).toHaveBeenCalledWith(
+        'pt',
+        expect.objectContaining({
+          variables: expect.objectContaining({
+            link: 'https://admin.com/confirm-email?token=confirm-tok',
+          }),
+        }),
+      );
+    });
+
+    it('lança NotFound quando o e-mail já está verificado', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_identifier.findFirst.mockResolvedValue(null);
+
+      await expect(
+        service.sendEmailConfirmationLink('pt', 1, 'a@b.com'),
+      ).rejects.toThrow(NotFoundException);
+      expect(deps.mail.sendTemplatedMail).not.toHaveBeenCalled();
+    });
+  });
+
   describe('verifyCodePassword', () => {
     it('retorna challenge quando válido', async () => {
       const { service, deps } = makeService();

package/src/challenge/challenge.service.ts

@@ -25,9 +25,12 @@ export class ChallengeService {
   /**
    * Resolve a chave do app (ex.: "class") a partir do header Origin da
    * requisicao, cruzando contra a setting `app-urls` (o mesmo mapeamento ja
-   * usado para montar links de e-mail por app). Usada para decidir a marca
-   * (`app-names`) em fluxos onde o frontend nao manda `app` explicitamente no
-   * corpo — o Origin ja chega sozinho em toda chamada cross-origin do browser.
+   * usado para montar links de e-mail por app), em fluxos onde o frontend nao
+   * manda `app` explicitamente no corpo — o Origin ja chega sozinho em toda
+   * chamada cross-origin do browser.
+   *
+   * Nao decide mais a marca do e-mail: `{{brandName}}` vem sempre de
+   * `system-name`.
    */
   async resolveAppKeyFromOrigin(origin?: string): Promise<string | undefined> {
     if (!origin) {
@@ -192,6 +195,62 @@ export class ChallengeService {
     return { challengeId: challenge.id  };
   }
 
+  /**
+   * Link de confirmação enviado no cadastro. Substitui o código de 6 dígitos que
+   * `verifyEmail` manda: no cadastro o `challengeId` nunca chegava ao frontend e
+   * nenhum app tinha tela para digitar o código, então o e-mail pedia algo
+   * impossível — e parte dos usuários respondia a mensagem com o código.
+   *
+   * `verifyEmail` continua como está porque a troca de e-mail no perfil devolve
+   * o `challengeId` e tem tela de código de verdade.
+   */
+  async sendEmailConfirmationLink(
+    locale: string,
+    userId: number,
+    email: string,
+    app?: string,
+    origin?: string,
+  ) {
+    const identifier = await this.prisma.user_identifier.findFirst({
+      where: {
+        user_id: userId,
+        type: 'email',
+        value: email,
+        verified_at: null,
+      },
+      select: { id: true },
+    });
+
+    if (!identifier) {
+      throw new NotFoundException(getLocaleText('identifierNotFound', locale, 'Email identifier not found or already verified.'));
+    }
+
+    const user = await this.prisma.user.findUnique({
+      where: { id: userId },
+      select: { name: true },
+    });
+
+    if (!user) {
+      throw new NotFoundException(getLocaleText('userNotFound', locale, 'User not found.'));
+    }
+
+    const settings = await this.setting.getSettingValues(['url', 'app-urls']);
+    const resolvedApp = app || (await this.resolveAppKeyFromOrigin(origin));
+    const token = await this.token.createEmailConfirmationToken({
+      userIdentifierId: identifier.id,
+    });
+
+    return this.mail.sendTemplatedMail(locale, {
+      email,
+      slug: 'auth-sign-up-confirm-email',
+      variables: {
+        link: `${this.resolveAppUrl(settings, resolvedApp)}/confirm-email?token=${encodeURIComponent(token)}`,
+        name: user.name,
+      },
+      app: resolvedApp,
+    });
+  }
+
   async verifyMultipleEmails(locale: string, userId: number, emails: string[]) {
 
     const settings = await this.setting.getSettingValues([

package/src/core.module.ts

@@ -18,6 +18,7 @@ import { FileModule } from './file/file.module';
 import { InstallModule } from './install/install.module';
 import { IntegrationModule } from './integration/integration.module';
 import { LocaleModule as CoreLocaleModule } from './locale/locale.module';
+import { MailDeliveryModule } from './mail-delivery/mail-delivery.module';
 import { MailSentModule } from './mail-sent/mail-sent.module';
 import { IncidentModule } from './incident/incident.module';
 import { LeakedPasswordModule } from './leaked-password/leaked-password.module';
@@ -43,6 +44,7 @@ import { SessionModule } from './session/session.module';
 import { SettingModule } from './setting/setting.module';
 import { SettingService } from './setting/setting.service';
 import { TaskModule } from './task/task.module';
+import { UserDeviceModule } from './user-device/user-device.module';
 import { UserModule } from './user/user.module';
 import { IsEmailWithSettingsConstraint } from './validators/is-email-with-settings.validator';
 import { IsPinCodeWithSettingConstraint } from './validators/is-pin-code-with-setting.validator';
@@ -50,7 +52,11 @@ import { IsStrongPasswordWithSettingsConstraint } from './validators/is-strong-p
 import { ValidatorServiceLocator } from './validators/service-locator';
 import { AiInstructionModule } from './ai-instruction/ai-instruction.module';
 import { AuthorizeModule } from './authorize/authorize.module';
+import { ImpersonationModule } from './impersonation/impersonation.module';
+import { PairingModule } from './pairing/pairing.module';
 import { IntegrationProfileModule } from './integration-profile/integration-profile.module';
+import { MailboxModule } from './mailbox/mailbox.module';
+import { MeetingModule } from './meeting/meeting.module';
 import { WebhookIntegrationModule } from './webhook-integration/webhook-integration.module';
 import { WhatsappSenderModule } from './whatsapp-sender/whatsapp-sender.module';
 
@@ -63,6 +69,8 @@ import { WhatsappSenderModule } from './whatsapp-sender/whatsapp-sender.module';
     forwardRef(() => InstallModule),
     forwardRef(() => AuthModule),
     forwardRef(() => AuthorizeModule),
+    forwardRef(() => PairingModule),
+    forwardRef(() => ImpersonationModule),
     forwardRef(() => DashboardModule),
     forwardRef(() => MailSendModule),
     forwardRef(() => MenuModule),
@@ -83,12 +91,14 @@ import { WhatsappSenderModule } from './whatsapp-sender/whatsapp-sender.module';
     forwardRef(() => IntegrationProfileModule),
     forwardRef(() => WhatsappSenderModule),
     forwardRef(() => MailSentModule),
+    forwardRef(() => MailDeliveryModule),
     forwardRef(() => FileModule),
     forwardRef(() => TaskModule),
     forwardRef(() => SecurityModule),
     forwardRef(() => CaptchaModule),
     forwardRef(() => ProfileModule),
     forwardRef(() => SessionModule),
+    forwardRef(() => UserDeviceModule),
     forwardRef(() => OAuthModule),
     forwardRef(() => IntegrationModule),
     forwardRef(() => WebhookIntegrationModule),
@@ -100,6 +110,9 @@ import { WhatsappSenderModule } from './whatsapp-sender/whatsapp-sender.module';
     forwardRef(() => AccessLogModule),
     forwardRef(() => RealtimeModule),
     forwardRef(() => PresenceModule),
+    MailboxModule,
+
+    MeetingModule,
   ],
   exports: [
     UserModule,
@@ -119,10 +132,16 @@ import { WhatsappSenderModule } from './whatsapp-sender/whatsapp-sender.module';
     SettingModule,
     FileModule,
     SessionModule,
+    ImpersonationModule,
+    UserDeviceModule,
     AiModule,
     AiInstructionModule,
     IntegrationModule,
+    MailDeliveryModule,
     WebhookIntegrationModule,
+    MailboxModule,
+
+    MeetingModule,
     OAuthModule,
     IsStrongPasswordWithSettingsConstraint,
     IsEmailWithSettingsConstraint,

package/src/file/file.controller.ts

@@ -2,6 +2,7 @@ import { Public, Role } from '@hed-hog/api';
 import { getLocaleText, Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
+  BadRequestException,
   Body,
   Controller,
   Delete,
@@ -13,6 +14,7 @@ import {
   ParseIntPipe,
   Post,
   Put,
+  Query,
   Req,
   Res,
   UploadedFile,
@@ -21,12 +23,21 @@ import {
 import { FileInterceptor } from '@nestjs/platform-express';
 import { Request, Response } from 'express';
 import { readFileSync } from 'fs';
+import { rm } from 'fs/promises';
 import Handlebars from 'handlebars';
+import { diskStorage } from 'multer';
+import { tmpdir } from 'os';
 import { join } from 'path';
 import { DeleteDTO } from './dto/delete.dto';
 import { UploadFileDTO } from './dto/upload.dto';
 import { FileService } from './file.service';
 
+// Teto duro do multipart, avaliado enquanto o corpo ainda está chegando. É
+// diferente do setting `storage-max-size`, que só roda depois do arquivo inteiro
+// já estar recebido e por isso nunca serviu de proteção de recurso.
+const MAX_UPLOAD_BYTES =
+  Number(process.env.STORAGE_MAX_UPLOAD_BYTES) || 2 * 1024 * 1024 * 1024;
+
 @Role()
 @Controller('file')
 export class FileController {
@@ -91,7 +102,7 @@ export class FileController {
   ) {
     const file = await this.fileService.get(id);
     const token = this.fileService.createDownloadToken(file.path, 3600);
-    const origin = `${req.protocol}://${req.get('host')}`;
+    const origin = await this.fileService.resolvePublicBaseUrl(req);
 
     return {
       url: `${origin}/file/open/${encodeURIComponent(token)}`,
@@ -105,7 +116,7 @@ export class FileController {
     ) {
       const file = await this.fileService.get(id);
       const token = this.fileService.createDownloadToken(file.path, 3600);
-      const origin = `${req.protocol}://${req.get('host')}`;
+      const origin = await this.fileService.resolvePublicBaseUrl(req);
 
     return {
         url: `${origin}/file/download/${encodeURIComponent(token)}`,
@@ -147,6 +158,11 @@ export class FileController {
     }
   }
 
+  /**
+   * `w`/`f`/`q` request a resized variant. Widths outside the configured
+   * allowlist are ignored and the original is served, so a stale URL sitting in
+   * someone's cached HTML degrades instead of failing.
+   */
   @Public()
   @Get('image/:id')
   async openImage(
@@ -154,6 +170,9 @@ export class FileController {
     @Req() req: Request,
     @Res() res: Response,
     @Locale() locale: string,
+    @Query('w') width?: string,
+    @Query('f') format?: string,
+    @Query('q') quality?: string,
   ) {
     try {
       await this.fileService.serveImageById(
@@ -161,6 +180,7 @@ export class FileController {
         id,
         req.headers['if-none-match'],
         res,
+        { width, format, quality },
       );
     } catch (error: any) {
       const html = this.renderDownloadErrorHtml(locale, error);
@@ -219,16 +239,46 @@ export class FileController {
     }
   }
 
+  // Grava o multipart em disco em vez de bufferizar na RAM: o memoryStorage padrão
+  // do multer fazia um Buffer.concat do arquivo inteiro antes de o handler rodar,
+  // o que derrubava o pod por OOM em uploads grandes (ex.: masters de vídeo do LMS
+  // de ~450 MB contra um limite de 1Gi). Daqui em diante o arquivo vai para o
+  // storage por streaming, via uploadFromPath.
   @Post()
-  @UseInterceptors(FileInterceptor('file'))
+  @UseInterceptors(
+    FileInterceptor('file', {
+      storage: diskStorage({ destination: tmpdir() }),
+      limits: { fileSize: MAX_UPLOAD_BYTES },
+    }),
+  )
   async upload(
     @UploadedFile() file: MulterFile,
     @Body() body: UploadFileDTO,
   ) {
+    if (!file?.path) {
+      throw new BadRequestException(`No file provided`);
+    }
+
     const destination = body.destination || 'files';
     const maxWidth = Number(body.maxWidth) || undefined;
     const maxHeight = Number(body.maxHeight) || undefined;
-    return this.fileService.upload(destination, file, { maxWidth, maxHeight });
+
+    try {
+      return await this.fileService.uploadFromPath(destination, file.path, {
+        originalname: file.originalname,
+        mimetype: file.mimetype,
+        size: file.size,
+        encoding: file.encoding,
+        resize: { maxWidth, maxHeight },
+      });
+    } finally {
+      // Sem isto o diskStorage troca o OOM por disk pressure no nó.
+      await rm(file.path, { force: true }).catch((error) =>
+        this.logger.warn(
+          `Failed to remove temporary upload ${file.path}: ${error?.message}`,
+        ),
+      );
+    }
   }
 
   @Delete()