@hed-hog/core 0.0.350 → 0.0.353

package/src/notification/notification.controller.ts

@@ -1,15 +1,18 @@
 import { Role, User } from '@hed-hog/api';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Req,
+    Res,
 } from '@nestjs/common';
+import type { Request, Response } from 'express';
 import { CreateNotificationDto } from './dto/create-notification.dto';
 import { UpdateProgressDto } from './dto/update-progress.dto';
 import { NotificationService } from './notification.service';
@@ -24,6 +27,15 @@ export class NotificationController {
     return this.notificationService.list(id, paginationParams);
   }
 
+  @Get('stream')
+  async stream(
+    @User() { id },
+    @Req() req: Request,
+    @Res() res: Response,
+  ) {
+    return this.notificationService.stream(id, req, res);
+  }
+
   @Get('unread-count')
   async unreadCount(@User() { id }) {
     return this.notificationService.unreadCount(id);

package/src/notification/notification.service.ts

@@ -5,19 +5,92 @@ import {
   forwardRef,
   Inject,
   Injectable,
+  Logger,
   NotFoundException,
+  OnModuleDestroy,
+  OnModuleInit,
 } from '@nestjs/common';
+import type { Request, Response } from 'express';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { Client, type Notification as PgNotification } from 'pg';
 import { CreateNotificationDto } from './dto/create-notification.dto';
 import { UpdateProgressDto } from './dto/update-progress.dto';
 
+type NotificationStreamEventType =
+  | 'ready'
+  | 'notification.created'
+  | 'notification.updated';
+
+type NotificationStreamEvent = {
+  type: NotificationStreamEventType;
+  notificationId?: number;
+  notification?: unknown;
+};
+
+type ClusterNotificationPayload = NotificationStreamEvent & {
+  userId: number;
+  originInstanceId: string;
+};
+
 @Injectable()
-export class NotificationService {
+export class NotificationService implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(NotificationService.name);
+  private readonly notificationEvents = new EventEmitter();
+  private readonly instanceId = randomUUID();
+  private readonly channelName = 'notification_events';
+  private pgClient: Client | null = null;
+
   constructor(
     @Inject(forwardRef(() => PrismaService))
     private readonly prisma: PrismaService,
     @Inject(forwardRef(() => PaginationService))
     private readonly pagination: PaginationService,
-  ) {}
+  ) {
+    this.notificationEvents.setMaxListeners(0);
+  }
+
+  async onModuleInit() {
+    const databaseUrl = String(process.env.DATABASE_URL || '');
+    if (!databaseUrl.startsWith('postgresql://')) {
+      this.logger.warn(
+        'Cluster notification stream disabled because DATABASE_URL is not PostgreSQL',
+      );
+      return;
+    }
+
+    this.pgClient = new Client({ connectionString: databaseUrl });
+    this.pgClient.on('notification', (message: PgNotification) => {
+      this.handleClusterNotification(message);
+    });
+    this.pgClient.on('error', (error) => {
+      this.logger.error('Cluster notification listener error', error);
+    });
+
+    await this.pgClient.connect();
+    await this.pgClient.query(`LISTEN ${this.channelName}`);
+    this.logger.log(
+      `Cluster notification listener ready on channel ${this.channelName}`,
+    );
+  }
+
+  async onModuleDestroy() {
+    if (!this.pgClient) {
+      return;
+    }
+
+    try {
+      await this.pgClient.query(`UNLISTEN ${this.channelName}`);
+    } catch (error) {
+      this.logger.warn('Failed to unlisten notification channel', error as any);
+    }
+
+    try {
+      await this.pgClient.end();
+    } finally {
+      this.pgClient = null;
+    }
+  }
 
   async list(userId: number, paginationParams: any) {
     return this.pagination.paginate(
@@ -40,35 +113,56 @@ export class NotificationService {
   async markRead(userId: number, id: number) {
     const notification = await this.assertOwnership(userId, id);
     if (notification.auto_remove) {
-      return this.prisma.notification.delete({ where: { id } });
+      const deleted = await this.prisma.notification.delete({ where: { id } });
+      await this.broadcastNotificationEvent(userId, {
+        type: 'notification.updated',
+        notificationId: id,
+      });
+      return deleted;
     }
-    return this.prisma.notification.update({
+    const updated = await this.prisma.notification.update({
       where: { id },
       data: { status: 'read' },
     });
+    await this.broadcastNotificationEvent(userId, {
+      type: 'notification.updated',
+      notificationId: id,
+    });
+    return updated;
   }
 
   async markAllRead(userId: number) {
     await this.prisma.notification.deleteMany({
       where: { user_id: userId, status: 'unread', auto_remove: true },
     });
-    return this.prisma.notification.updateMany({
+    const updated = await this.prisma.notification.updateMany({
       where: { user_id: userId, status: 'unread' },
       data: { status: 'read' },
     });
+    await this.broadcastNotificationEvent(userId, { type: 'notification.updated' });
+    return updated;
   }
 
   async delete(userId: number, id: number) {
     await this.assertOwnership(userId, id);
-    return this.prisma.notification.delete({ where: { id } });
+    const deleted = await this.prisma.notification.delete({ where: { id } });
+    await this.broadcastNotificationEvent(userId, {
+      type: 'notification.updated',
+      notificationId: id,
+    });
+    return deleted;
   }
 
   async deleteAll(userId: number) {
-    return this.prisma.notification.deleteMany({ where: { user_id: userId } });
+    const result = await this.prisma.notification.deleteMany({
+      where: { user_id: userId },
+    });
+    await this.broadcastNotificationEvent(userId, { type: 'notification.updated' });
+    return result;
   }
 
   async create(data: CreateNotificationDto) {
-    return this.prisma.notification.create({
+    const notification = await this.prisma.notification.create({
       data: {
         user_id: data.user_id,
         title: data.title,
@@ -83,12 +177,18 @@ export class NotificationService {
         started_at: data.started_at ? new Date(data.started_at) : undefined,
       },
     });
+    await this.broadcastNotificationEvent(data.user_id, {
+      type: 'notification.created',
+      notificationId: notification.id,
+      notification,
+    });
+    return notification;
   }
 
   async updateProgress(userId: number, id: number, dto: UpdateProgressDto) {
     await this.assertOwnership(userId, id);
     const finished = dto.progress >= 100;
-    return this.prisma.notification.update({
+    const notification = await this.prisma.notification.update({
       where: { id },
       data: {
         progress: dto.progress,
@@ -97,6 +197,51 @@ export class NotificationService {
         finished_at: finished ? new Date() : undefined,
       },
     });
+    await this.broadcastNotificationEvent(userId, {
+      type: 'notification.updated',
+      notificationId: id,
+      notification,
+    });
+    return notification;
+  }
+
+  stream(userId: number, req: Request, res: Response) {
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+
+    const writeEvent = (event: NotificationStreamEvent) => {
+      if (res.writableEnded) {
+        return;
+      }
+
+      res.write(`event: ${event.type}\n`);
+      res.write(`data: ${JSON.stringify(event)}\n\n`);
+    };
+
+    const eventKey = this.getEventKey(userId);
+    const handler = (event: NotificationStreamEvent) => {
+      writeEvent(event);
+    };
+
+    this.notificationEvents.on(eventKey, handler);
+    writeEvent({ type: 'ready' });
+
+    const heartbeat = setInterval(() => {
+      if (!res.writableEnded) {
+        res.write(': ping\n\n');
+      }
+    }, 25000);
+
+    const cleanup = () => {
+      clearInterval(heartbeat);
+      this.notificationEvents.off(eventKey, handler);
+    };
+
+    req.on('close', cleanup);
+    res.on('close', cleanup);
   }
 
   async clearOldNotifications(retentionDays: number, batchLimit: number) {
@@ -121,4 +266,59 @@ export class NotificationService {
     if (notification.user_id !== userId) throw new ForbiddenException();
     return notification;
   }
+
+  private async broadcastNotificationEvent(
+    userId: number,
+    event: NotificationStreamEvent,
+  ) {
+    this.emitLocalNotificationEvent(userId, event);
+
+    const payload: ClusterNotificationPayload = {
+      ...event,
+      userId,
+      originInstanceId: this.instanceId,
+    };
+
+    try {
+      await this.prisma.$executeRaw`
+        SELECT pg_notify(${this.channelName}, ${JSON.stringify(payload)})
+      `;
+    } catch (error) {
+      this.logger.warn('Failed to broadcast notification event', error as any);
+    }
+  }
+
+  private getEventKey(userId: number) {
+    return `notification:${userId}`;
+  }
+
+  private emitLocalNotificationEvent(
+    userId: number,
+    event: NotificationStreamEvent,
+  ) {
+    this.notificationEvents.emit(this.getEventKey(userId), event);
+  }
+
+  private handleClusterNotification(message: PgNotification) {
+    if (message.channel !== this.channelName || !message.payload) {
+      return;
+    }
+
+    let payload: ClusterNotificationPayload;
+    try {
+      payload = JSON.parse(message.payload) as ClusterNotificationPayload;
+    } catch {
+      return;
+    }
+
+    if (!payload || payload.originInstanceId === this.instanceId) {
+      return;
+    }
+
+    this.emitLocalNotificationEvent(payload.userId, {
+      type: payload.type,
+      notificationId: payload.notificationId,
+      notification: payload.notification,
+    });
+  }
 }

package/src/pdf/pdf.service.ts

@@ -182,7 +182,7 @@ export class PdfService {
 
       if (missingRuntime) {
         throw new InternalServerErrorException(
-          'Playwright runtime is not available. Run `npx playwright install chromium` in apps/api.',
+          'Playwright runtime is not available. Run `pnpm --filter api run playwright:install` in the API environment.',
         );
       }
 

package/src/profile/profile.controller.ts

@@ -81,7 +81,7 @@ export class ProfileController {
 
   @Post('mfa/email/verify/confirm')
   sendEmailVerificationMfaConfirm(@User() {id}, @Body() data: EmailVerificationDto, @Locale() locale: string) {
-    console.log('sendEmailVerificationMfaConfirm')
+    
     return this.profileService.confirmEmailVerificationMfa(locale, id, data);
   }
   

package/src/profile/profile.module.ts

@@ -17,5 +17,6 @@ import { ProfileService } from './profile.service';
   ],
   controllers: [ProfileController],
   providers: [ProfileService],
+  exports: [ProfileService],
 })
 export class ProfileModule {}

package/src/setting/setting.service.ts

@@ -3,12 +3,12 @@ import { getLocaleText, LocaleService } 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 {
-    BadRequestException,
-    forwardRef,
-    Inject,
-    Injectable,
-    Logger,
-    NotFoundException
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException
 } from '@nestjs/common';
 import * as pako from 'pako';
 import { IntegrationDeveloperApiService } from '../integration/services/integration-developer-api.service';
@@ -208,6 +208,7 @@ export class SettingService {
       'mfa-email-code-length',
       'ai-openai-api-key-enabled',
       'ai-gemini-api-key-enabled',
+      'mcp-enabled',
       'date-format',
       'time-format',
       'timezone',
@@ -974,8 +975,6 @@ export class SettingService {
       this.cachedSettings &&
       slugs.every(s => Object.prototype.hasOwnProperty.call(this.cachedSettings, s))
     ) {
-      this.logger.debug('Returning settings from cache');
-
       // Retorna apenas os slugs requisitados do cache
       const cached: Record<string, any> = {};
       slugs.forEach(s => {
@@ -984,7 +983,7 @@ export class SettingService {
       return cached;
     }
 
-    this.logger.debug('Fetching settings from database');
+    
 
     slug = Array.isArray(slug) ? slug : [slug];
 
@@ -1064,7 +1063,6 @@ export class SettingService {
   }
 
   setCache(value: Record<string, any>) {
-    this.logger.debug(`Setting settings cache with ${Object.keys(value).length} items`);
     Object.keys(value).forEach(key => {
       this.cachedSettings[key] = value[key];
     });
@@ -1072,7 +1070,6 @@ export class SettingService {
   }
 
   clearCache() {
-    this.logger.debug('Clearing settings cache');
     this.cachedSettings = {};
   }
 

package/src/task/task.service.ts

@@ -42,6 +42,9 @@ export class TasksService {
     await this.clearOldNotifications();
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
 
+    await this.clearOldAccessLogs();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
     this.logger.verbose('Finished scheduled cleanup tasks');
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
   }
@@ -270,6 +273,34 @@ export class TasksService {
     );
   }
 
+  private async clearOldAccessLogs(): Promise<void> {
+    const settings = await this.settingService.getSettingValues([
+      'cleanup-batch-limit',
+      'access-log-retention-days',
+    ]);
+    const batchLimit = Number(settings['cleanup-batch-limit']) || 20000;
+    const retentionDays = Number(settings['access-log-retention-days']) || 30;
+    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
+    `;
+
+    this.logger.verbose(
+      `Old access logs cleaned up in ${Date.now() - startAt}ms`,
+    );
+  }
+
   private async clearOldNotifications(): Promise<void> {
     const settings = await this.settingService.getSettingValues([
       'cleanup-batch-limit',

package/src/token/token.service.ts

@@ -51,8 +51,6 @@ export class TokenService {
       return payload;
     } catch (error) {
 
-      console.log('JWT ERROR', error);
-
       // Return 401 for JWT errors (expired, invalid, etc.)
       throw new UnauthorizedException(
         (error as any).message || getLocaleText('accessDenied', locale, 'Access denied.')

package/src/webhook-integration/dto/webhook-action.dto.ts

@@ -0,0 +1,96 @@
+import { Transform } from 'class-transformer';
+import { PartialType } from '@nestjs/mapped-types';
+import { IsIn, IsInt, IsOptional, IsString } from 'class-validator';
+
+const toNullableInteger = ({ value }: { value: unknown }) => {
+  if (value === undefined || value === null || value === '') {
+    return undefined;
+  }
+
+  return Number(value);
+};
+
+const toOptionalTrimmedString = ({ value }: { value: unknown }) => {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  return String(value).trim();
+};
+
+export class CreateWebhookActionDTO {
+  @IsIn(['email', 'whatsapp_evolution'])
+  type: 'email' | 'whatsapp_evolution';
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @Transform(toNullableInteger)
+  @IsInt()
+  order?: number;
+
+  @IsOptional()
+  @IsIn(['active', 'inactive'])
+  status?: 'active' | 'inactive';
+
+  @IsOptional()
+  @Transform(toNullableInteger)
+  @IsInt()
+  mail_profile_id?: number;
+
+  @IsOptional()
+  @Transform(toNullableInteger)
+  @IsInt()
+  mail_id?: number;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  email_to?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  email_cc?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  email_bcc?: string;
+
+  @IsOptional()
+  @IsIn(['phone', 'group'])
+  whatsapp_target_type?: 'phone' | 'group';
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  whatsapp_target?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  whatsapp_template?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  whatsapp_instance?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  whatsapp_base_url?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  whatsapp_token?: string;
+}
+
+export class UpdateWebhookActionDTO extends PartialType(
+  CreateWebhookActionDTO,
+) {}