@hed-hog/core 0.0.349 → 0.0.351

package/src/setting/setting.service.ts

@@ -3,18 +3,19 @@ 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';
 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 = {
@@ -207,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',
@@ -497,6 +499,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 +525,16 @@ export class SettingService {
               description: true,
             },
           },
+          setting_list: {
+            select: {
+              id: true,
+              order: true,
+              value: true,
+            },
+            orderBy: {
+              order: 'asc',
+            },
+          },
         },
       },
       'setting_locale',
@@ -518,12 +545,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 },
@@ -883,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 => {
@@ -893,7 +983,7 @@ export class SettingService {
       return cached;
     }
 
-    this.logger.debug('Fetching settings from database');
+    
 
     slug = Array.isArray(slug) ? slug : [slug];
 
@@ -973,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];
     });
@@ -981,7 +1070,6 @@ export class SettingService {
   }
 
   clearCache() {
-    this.logger.debug('Clearing settings cache');
     this.cachedSettings = {};
   }
 

package/src/task/task.service.ts

@@ -36,6 +36,15 @@ export class TasksService {
     await this.clearUnverifiedMfaWithExpiredChallenges();
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
 
+    await this.clearExpiredWebhookLogs();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
+    await this.clearOldNotifications();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
+    await this.clearOldAccessLogs();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
     this.logger.verbose('Finished scheduled cleanup tasks');
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
   }
@@ -225,4 +234,98 @@ 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 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',
+      '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`,
+    );
+  }
 }

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,
+) {}

package/src/webhook-integration/webhook-integration.controller.ts

@@ -1,103 +1,124 @@
-import { DeleteDTO, Public, Role } from '@hed-hog/api';
-import { Pagination } from '@hed-hog/api-pagination';
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Headers,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
-  Req,
-} from '@nestjs/common';
-import { Request } from 'express';
-import { WebhookIntegrationService } from './webhook-integration.service';
-
-@Role()
-@Controller('webhook-integration')
-export class WebhookIntegrationController {
-  constructor(private readonly service: WebhookIntegrationService) {}
-
-  @Get()
-  list(@Pagination() paginationParams) {
-    return this.service.list(paginationParams);
-  }
-
-  @Get(':id')
-  get(@Param('id', ParseIntPipe) id: number) {
-    return this.service.get(id);
-  }
-
-  @Post()
-  create(@Body() data: any) {
-    return this.service.create(data);
-  }
-
-  @Patch(':id')
-  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
-    return this.service.update(id, data);
-  }
-
-  @Delete()
-  delete(@Body() data: DeleteDTO) {
-    return this.service.delete(data);
-  }
-
-  @Post(':id/regenerate-uuid')
-  regenerateUuid(@Param('id', ParseIntPipe) id: number) {
-    return this.service.regenerateUuid(id);
-  }
-
-  @Post(':id/regenerate-token')
-  regenerateToken(@Param('id', ParseIntPipe) id: number) {
-    return this.service.regenerateToken(id);
-  }
-
-  @Get(':id/action')
-  listActions(@Param('id', ParseIntPipe) id: number) {
-    return this.service.listActions(id);
-  }
-
-  @Post(':id/action')
-  createAction(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
-    return this.service.createAction(id, data);
-  }
-
-  @Patch(':id/action/:actionId')
-  updateAction(
-    @Param('id', ParseIntPipe) id: number,
-    @Param('actionId', ParseIntPipe) actionId: number,
-    @Body() data: any,
-  ) {
-    return this.service.updateAction(id, actionId, data);
-  }
-
-  @Delete(':id/action')
-  deleteActions(@Param('id', ParseIntPipe) id: number, @Body() data: DeleteDTO) {
-    return this.service.deleteActions(id, data);
-  }
-
-  @Get(':id/log')
-  listLogs(@Param('id', ParseIntPipe) id: number, @Pagination() paginationParams) {
-    return this.service.listLogs(id, paginationParams);
-  }
-}
-
-@Public()
-@Controller('webhook')
-export class PublicWebhookController {
-  constructor(private readonly service: WebhookIntegrationService) {}
-
-  @Post(':uuid')
-  execute(
-    @Param('uuid') uuid: string,
-    @Body() body: any,
-    @Headers() headers: any,
-    @Req() req: Request,
-  ) {
-    return this.service.executePublic(uuid, body, headers, req);
-  }
-}
-
+import { DeleteDTO, Public, Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Headers,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+  Req,
+  Res,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+import { WebhookIntegrationService } from './webhook-integration.service';
+import {
+  CreateWebhookActionDTO,
+  UpdateWebhookActionDTO,
+} from './dto/webhook-action.dto';
+
+@Role()
+@Controller('webhook-integration')
+export class WebhookIntegrationController {
+  constructor(private readonly service: WebhookIntegrationService) {}
+
+  @Get()
+  list(@Pagination() paginationParams) {
+    return this.service.list(paginationParams);
+  }
+
+  @Get(':id')
+  get(@Param('id', ParseIntPipe) id: number) {
+    return this.service.get(id);
+  }
+
+  @Post()
+  create(@Body() data: any) {
+    return this.service.create(data);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
+    return this.service.update(id, data);
+  }
+
+  @Delete()
+  delete(@Body() data: DeleteDTO) {
+    return this.service.delete(data);
+  }
+
+  @Post(':id/regenerate-uuid')
+  regenerateUuid(@Param('id', ParseIntPipe) id: number) {
+    return this.service.regenerateUuid(id);
+  }
+
+  @Post(':id/regenerate-token')
+  regenerateToken(@Param('id', ParseIntPipe) id: number) {
+    return this.service.regenerateToken(id);
+  }
+
+  @Get(':id/action')
+  listActions(@Param('id', ParseIntPipe) id: number) {
+    return this.service.listActions(id);
+  }
+
+  @Post(':id/action')
+  createAction(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: CreateWebhookActionDTO,
+  ) {
+    return this.service.createAction(id, data);
+  }
+
+  @Patch(':id/action/:actionId')
+  updateAction(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('actionId', ParseIntPipe) actionId: number,
+    @Body() data: UpdateWebhookActionDTO,
+  ) {
+    return this.service.updateAction(id, actionId, data);
+  }
+
+  @Delete(':id/action')
+  deleteActions(@Param('id', ParseIntPipe) id: number, @Body() data: DeleteDTO) {
+    return this.service.deleteActions(id, data);
+  }
+
+  @Get(':id/log')
+  listLogs(
+    @Param('id', ParseIntPipe) id: number,
+    @Pagination() paginationParams,
+    @Query('sort') sort?: 'asc' | 'desc',
+  ) {
+    return this.service.listLogs(id, paginationParams, sort);
+  }
+
+  @Get(':id/log/stream')
+  streamLogs(
+    @Param('id', ParseIntPipe) id: number,
+    @Res() res: Response,
+  ) {
+    return this.service.streamLogs(id, res);
+  }
+}
+
+@Public()
+@Controller('webhook')
+export class PublicWebhookController {
+  constructor(private readonly service: WebhookIntegrationService) {}
+
+  @Post(':uuid')
+  execute(
+    @Param('uuid') uuid: string,
+    @Body() body: any,
+    @Headers() headers: any,
+    @Req() req: Request,
+  ) {
+    return this.service.executePublic(uuid, body, headers, req);
+  }
+}
+