@hed-hog/core 0.0.347 → 0.0.350

package/src/notification/dto/create-notification.dto.ts

@@ -0,0 +1,71 @@
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  Max,
+  Min,
+} from 'class-validator';
+
+export enum NotificationType {
+  Info = 'info',
+  Success = 'success',
+  Warning = 'warning',
+  Error = 'error',
+  Progress = 'progress',
+}
+
+export enum NotificationActionType {
+  Url = 'url',
+  Sheet = 'sheet',
+  Modal = 'modal',
+}
+
+export class CreateNotificationDto {
+  @IsNumber()
+  user_id: number;
+
+  @IsString()
+  title: string;
+
+  @IsOptional()
+  @IsString()
+  body?: string;
+
+  @IsOptional()
+  @IsString()
+  icon?: string;
+
+  @IsOptional()
+  @IsEnum(NotificationType)
+  type?: NotificationType;
+
+  @IsOptional()
+  @IsEnum(NotificationActionType)
+  action_type?: NotificationActionType;
+
+  @IsOptional()
+  @IsObject()
+  action_data?: Record<string, unknown>;
+
+  @IsOptional()
+  @IsString()
+  action_url?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  auto_remove?: boolean;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  @Max(100)
+  progress?: number;
+
+  @IsOptional()
+  @IsDateString()
+  started_at?: string;
+}

package/src/notification/dto/update-progress.dto.ts

@@ -0,0 +1,16 @@
+import { IsBoolean, IsNumber, IsOptional, IsString, Max, Min } from 'class-validator';
+
+export class UpdateProgressDto {
+  @IsNumber()
+  @Min(0)
+  @Max(100)
+  progress: number;
+
+  @IsOptional()
+  @IsString()
+  body?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  success?: boolean;
+}

package/src/notification/notification.controller.ts

@@ -0,0 +1,71 @@
+import { Role, User } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { CreateNotificationDto } from './dto/create-notification.dto';
+import { UpdateProgressDto } from './dto/update-progress.dto';
+import { NotificationService } from './notification.service';
+
+@Role()
+@Controller('notification')
+export class NotificationController {
+  constructor(private readonly notificationService: NotificationService) {}
+
+  @Get()
+  async list(@User() { id }, @Pagination() paginationParams) {
+    return this.notificationService.list(id, paginationParams);
+  }
+
+  @Get('unread-count')
+  async unreadCount(@User() { id }) {
+    return this.notificationService.unreadCount(id);
+  }
+
+  @Patch('read-all')
+  async markAllRead(@User() { id }) {
+    return this.notificationService.markAllRead(id);
+  }
+
+  @Patch(':id/read')
+  async markRead(
+    @User() { id: userId },
+    @Param('id', ParseIntPipe) id: number,
+  ) {
+    return this.notificationService.markRead(userId, id);
+  }
+
+  @Patch(':id/progress')
+  async updateProgress(
+    @User() { id: userId },
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateProgressDto,
+  ) {
+    return this.notificationService.updateProgress(userId, id, dto);
+  }
+
+  @Delete()
+  async deleteAll(@User() { id }) {
+    return this.notificationService.deleteAll(id);
+  }
+
+  @Delete(':id')
+  async delete(
+    @User() { id: userId },
+    @Param('id', ParseIntPipe) id: number,
+  ) {
+    return this.notificationService.delete(userId, id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateNotificationDto) {
+    return this.notificationService.create(data);
+  }
+}

package/src/notification/notification.module.ts

@@ -0,0 +1,16 @@
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { NotificationController } from './notification.controller';
+import { NotificationService } from './notification.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+  controllers: [NotificationController],
+  providers: [NotificationService],
+  exports: [NotificationService],
+})
+export class NotificationModule {}

package/src/notification/notification.service.ts

@@ -0,0 +1,124 @@
+import { PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  ForbiddenException,
+  forwardRef,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { CreateNotificationDto } from './dto/create-notification.dto';
+import { UpdateProgressDto } from './dto/update-progress.dto';
+
+@Injectable()
+export class NotificationService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly pagination: PaginationService,
+  ) {}
+
+  async list(userId: number, paginationParams: any) {
+    return this.pagination.paginate(
+      this.prisma.notification,
+      paginationParams,
+      {
+        where: { user_id: userId },
+        orderBy: { created_at: 'desc' },
+      },
+    );
+  }
+
+  async unreadCount(userId: number) {
+    const count = await this.prisma.notification.count({
+      where: { user_id: userId, status: 'unread' },
+    });
+    return { count };
+  }
+
+  async markRead(userId: number, id: number) {
+    const notification = await this.assertOwnership(userId, id);
+    if (notification.auto_remove) {
+      return this.prisma.notification.delete({ where: { id } });
+    }
+    return this.prisma.notification.update({
+      where: { id },
+      data: { status: 'read' },
+    });
+  }
+
+  async markAllRead(userId: number) {
+    await this.prisma.notification.deleteMany({
+      where: { user_id: userId, status: 'unread', auto_remove: true },
+    });
+    return this.prisma.notification.updateMany({
+      where: { user_id: userId, status: 'unread' },
+      data: { status: 'read' },
+    });
+  }
+
+  async delete(userId: number, id: number) {
+    await this.assertOwnership(userId, id);
+    return this.prisma.notification.delete({ where: { id } });
+  }
+
+  async deleteAll(userId: number) {
+    return this.prisma.notification.deleteMany({ where: { user_id: userId } });
+  }
+
+  async create(data: CreateNotificationDto) {
+    return this.prisma.notification.create({
+      data: {
+        user_id: data.user_id,
+        title: data.title,
+        body: data.body,
+        icon: data.icon,
+        type: (data.type as any) ?? 'info',
+        action_type: (data.action_type as any) ?? 'url',
+        action_data: data.action_data as any,
+        action_url: data.action_url,
+        auto_remove: data.auto_remove ?? false,
+        progress: data.progress,
+        started_at: data.started_at ? new Date(data.started_at) : undefined,
+      },
+    });
+  }
+
+  async updateProgress(userId: number, id: number, dto: UpdateProgressDto) {
+    await this.assertOwnership(userId, id);
+    const finished = dto.progress >= 100;
+    return this.prisma.notification.update({
+      where: { id },
+      data: {
+        progress: dto.progress,
+        body: dto.body,
+        type: finished ? (dto.success === false ? 'error' : 'success') as any : undefined,
+        finished_at: finished ? new Date() : undefined,
+      },
+    });
+  }
+
+  async clearOldNotifications(retentionDays: number, batchLimit: number) {
+    return this.prisma.$executeRawUnsafe(
+      `WITH del AS (
+         SELECT id FROM notification
+         WHERE created_at < NOW() - INTERVAL '${retentionDays} days'
+         ORDER BY id
+         LIMIT ${batchLimit}
+       )
+       DELETE FROM notification n
+       USING del WHERE n.id = del.id`,
+    );
+  }
+
+  private async assertOwnership(userId: number, id: number) {
+    const notification = await this.prisma.notification.findUnique({
+      where: { id },
+      select: { user_id: true, auto_remove: true },
+    });
+    if (!notification) throw new NotFoundException();
+    if (notification.user_id !== userId) throw new ForbiddenException();
+    return notification;
+  }
+}

package/src/setting/dto/update-setting-list.dto.ts

@@ -0,0 +1,32 @@
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsInt,
+  IsOptional,
+  IsString,
+  Length,
+  ValidateNested,
+} from 'class-validator';
+
+export class UpdateSettingListItemDTO {
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  id?: number;
+
+  @IsString()
+  @Length(1, 255)
+  value: string;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  order?: number;
+}
+
+export class UpdateSettingListDTO {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => UpdateSettingListItemDTO)
+  options: UpdateSettingListItemDTO[];
+}

package/src/setting/setting.controller.ts

@@ -27,6 +27,7 @@ import { DeleteDTO } from './dto/delete.dto';
 import { ExportDto } from './dto/export.dto';
 import { SettingUserDTO } from './dto/setting-user.dto';
 import { SettingDTO } from './dto/setting.dto';
+import { UpdateSettingListDTO } from './dto/update-setting-list.dto';
 import { UpdateDTO } from './dto/update.dto';
 import { SettingService } from './setting.service';
 
@@ -124,6 +125,14 @@ export class SettingsController {
     return this.settingService.updateFromSlug(slug, data);
   }
 
+  @Put(':settingId/options')
+  async updateSettingListOptions(
+    @Param('settingId', ParseIntPipe) settingId: number,
+    @Body() data: UpdateSettingListDTO,
+  ) {
+    return this.settingService.updateSettingListOptions(settingId, data);
+  }
+
   @Put()
   async setManySettings(@Body() data: SettingDTO) {
     return this.settingService.setManySettings(data);

package/src/setting/setting.service.ts

@@ -15,6 +15,7 @@ import { IntegrationDeveloperApiService } from '../integration/services/integrat
 import { CreateDTO } from './dto/create.dto';
 import { DeleteDTO } from './dto/delete.dto';
 import { SettingDTO } from './dto/setting.dto';
+import { UpdateSettingListDTO } from './dto/update-setting-list.dto';
 import { UpdateDTO } from './dto/update.dto';
 
 type SettingChangeEventInput = {
@@ -497,6 +498,21 @@ export class SettingService {
               },
             },
           },
+          setting_subgroup: {
+            include: {
+              setting_subgroup_locale: {
+                where: {
+                  locale: {
+                    code: locale,
+                  },
+                },
+                select: {
+                  name: true,
+                  description: true,
+                },
+              },
+            },
+          },
           setting_locale: {
             where: {
               locale: {
@@ -508,6 +524,16 @@ export class SettingService {
               description: true,
             },
           },
+          setting_list: {
+            select: {
+              id: true,
+              order: true,
+              value: true,
+            },
+            orderBy: {
+              order: 'asc',
+            },
+          },
         },
       },
       'setting_locale',
@@ -518,12 +544,77 @@ export class SettingService {
         'setting_group_locale',
         setting.setting_group,
       );
+
+      if (setting.setting_subgroup) {
+        setting.setting_subgroup = itemTranslations(
+          'setting_subgroup_locale',
+          setting.setting_subgroup,
+        );
+      }
+
+      setting.subgroupId ??=
+        setting.subgroup_id ?? setting.setting_subgroup?.id ?? null;
+
       return setting;
     });
 
     return result;
   }
 
+  async updateSettingListOptions(settingId: number, data: UpdateSettingListDTO) {
+    this.clearCache();
+
+    const setting = await this.prismaService.setting.findUnique({
+      where: { id: settingId },
+      select: {
+        id: true,
+        component: true,
+      },
+    });
+
+    if (!setting) {
+      throw new NotFoundException(`Setting with ID ${settingId} not found.`);
+    }
+
+    const component = String(setting.component ?? '').toLowerCase();
+    if (component !== 'combobox' && component !== 'checkbox') {
+      throw new BadRequestException(
+        'Only combobox and checkbox settings support list options.',
+      );
+    }
+
+    const options = (data.options ?? [])
+      .map((option, index) => ({
+        value: option.value?.trim() ?? '',
+        order: option.order ?? index + 1,
+      }))
+      .filter((option) => option.value.length > 0);
+
+    const updatedSetting = await this.prismaService.setting.update({
+      where: { id: settingId },
+      data: {
+        setting_list: {
+          deleteMany: {},
+          create: options,
+        },
+      },
+      include: {
+        setting_list: {
+          select: {
+            id: true,
+            order: true,
+            value: true,
+          },
+          orderBy: {
+            order: 'asc',
+          },
+        },
+      },
+    });
+
+    return updatedSetting;
+  }
+
   async get(settingId: number) {
     const setting = await this.prismaService.setting.findUnique({
       where: { id: settingId },

package/src/task/task.service.ts

@@ -36,6 +36,12 @@ export class TasksService {
     await this.clearUnverifiedMfaWithExpiredChallenges();
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
 
+    await this.clearExpiredWebhookLogs();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
+    await this.clearOldNotifications();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
     this.logger.verbose('Finished scheduled cleanup tasks');
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
   }
@@ -225,4 +231,70 @@ export class TasksService {
       `Unverified MFA with expired challenges cleaned up in ${Date.now() - startAt}ms`,
     );
   }
+
+  /**
+   * Limpa logs antigos de execução de webhooks de entrada com base na política
+   * de retenção configurada em settings.
+   *
+   * Remove registros da tabela webhook_call_log que:
+   * - Foram criados há mais dias do que o valor de webhook-log-retention-days
+   *
+   * Os registros relacionados em webhook_action_log são removidos em cascata
+   * pelo relacionamento FK com onDelete CASCADE.
+   */
+  private async clearExpiredWebhookLogs(): Promise<void> {
+    const settings = await this.settingService.getSettingValues([
+      'cleanup-batch-limit',
+      'webhook-log-retention-days',
+    ]);
+    const batchLimit = Number(settings['cleanup-batch-limit']) || 20000;
+    const retentionDays = Number(settings['webhook-log-retention-days']) || 30;
+    this.logger.verbose('Starting cleanup of expired webhook call logs');
+    const startAt = Date.now();
+
+    await this.prismaService.$executeRaw`
+      WITH del AS (
+        SELECT id
+        FROM webhook_call_log
+        WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
+        ORDER BY id
+        LIMIT ${batchLimit}
+      )
+      DELETE FROM webhook_call_log wcl
+      USING del
+      WHERE wcl.id = del.id
+    `;
+
+    this.logger.verbose(
+      `Expired webhook call logs cleaned up in ${Date.now() - startAt}ms`,
+    );
+  }
+
+  private async clearOldNotifications(): Promise<void> {
+    const settings = await this.settingService.getSettingValues([
+      'cleanup-batch-limit',
+      'notification-retention-days',
+    ]);
+    const batchLimit = Number(settings['cleanup-batch-limit']) || 20000;
+    const retentionDays = Number(settings['notification-retention-days']) || 30;
+    this.logger.verbose('Starting cleanup of old notifications');
+    const startAt = Date.now();
+
+    await this.prismaService.$executeRaw`
+      WITH del AS (
+        SELECT id
+        FROM notification
+        WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
+        ORDER BY id
+        LIMIT ${batchLimit}
+      )
+      DELETE FROM notification n
+      USING del
+      WHERE n.id = del.id
+    `;
+
+    this.logger.verbose(
+      `Old notifications cleaned up in ${Date.now() - startAt}ms`,
+    );
+  }
 }