@hed-hog/core 0.0.350 → 0.0.353

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);
+  }
+}
+

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

@@ -4,23 +4,28 @@ import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import { HttpService } from '@nestjs/axios';
 import {
-  BadRequestException,
-  HttpException,
-  Injectable,
-  NotFoundException,
+    BadRequestException,
+    HttpException,
+    Injectable,
+    NotFoundException,
 } from '@nestjs/common';
-import { Request } from 'express';
+import { EventEmitter } from 'events';
+import { Request, Response } from 'express';
 import { firstValueFrom } from 'rxjs';
 import { MailService } from '../mail/mail.service';
 import { SettingService } from '../setting/setting.service';
 import {
-  createPlainToken,
-  createPublicUuid,
-  hashToken,
-  normalizeJsonObject,
-  renderTemplate,
-  sanitizeSensitiveData,
-  summarizePayload,
+  CreateWebhookActionDTO,
+  UpdateWebhookActionDTO,
+} from './dto/webhook-action.dto';
+import {
+    createPlainToken,
+    createPublicUuid,
+    hashToken,
+    normalizeJsonObject,
+    renderTemplate,
+    sanitizeSensitiveData,
+    summarizePayload,
 } from './webhook-utils';
 
 type ActionExecutionLog = {
@@ -34,8 +39,15 @@ type ActionExecutionLog = {
   errorMessage?: string | null;
 };
 
+type WebhookActionPayload =
+  | CreateWebhookActionDTO
+  | UpdateWebhookActionDTO
+  | Record<string, unknown>;
+
 @Injectable()
 export class WebhookIntegrationService {
+  private readonly logEmitter = new EventEmitter();
+
   constructor(
     private readonly prisma: PrismaService,
     private readonly pagination: PaginationService,
@@ -192,8 +204,11 @@ export class WebhookIntegrationService {
   }
 
   private async getApplicationBaseUrl() {
-    const settings = await this.settingService.getSettingValues('url');
-    const value = settings?.url;
+    const settings = await this.settingService.getSettingValues([
+      'api-url',
+      'url',
+    ]);
+    const value = settings?.['api-url'] || settings?.url;
     return typeof value === 'string' ? value.replace(/\/+$/, '') : '';
   }
 
@@ -231,21 +246,34 @@ export class WebhookIntegrationService {
     });
   }
 
-  async createAction(integrationId: number, data: any) {
+  async createAction(integrationId: number, data: WebhookActionPayload) {
     await this.get(integrationId);
+    const normalized = this.normalizeAction(data);
+    this.validateActionConfiguration(normalized);
+
     return this.actions.create({
       data: {
-        ...this.normalizeAction(data),
+        ...normalized,
         webhook_integration_id: integrationId,
       },
     });
   }
 
-  async updateAction(integrationId: number, actionId: number, data: any) {
-    await this.ensureAction(integrationId, actionId);
+  async updateAction(
+    integrationId: number,
+    actionId: number,
+    data: WebhookActionPayload,
+  ) {
+    const existing = await this.ensureAction(integrationId, actionId);
+    const normalized = this.normalizeAction(data, true);
+    this.validateActionConfiguration({
+      ...existing,
+      ...normalized,
+    });
+
     return this.actions.update({
       where: { id: actionId },
-      data: this.normalizeAction(data, true),
+      data: normalized,
     });
   }
 
@@ -265,12 +293,40 @@ export class WebhookIntegrationService {
     });
   }
 
-  async listLogs(integrationId: number, paginationParams: PaginationDTO) {
+  async listLogs(
+    integrationId: number,
+    paginationParams: PaginationDTO,
+    sort: 'asc' | 'desc' = 'desc',
+  ) {
     await this.get(integrationId);
-    const result = await this.pagination.paginate(this.logs, paginationParams, {
-      where: { webhook_integration_id: integrationId },
-      orderBy: [{ created_at: 'desc' }, { id: 'desc' }],
-    });
+
+    const page = Math.max(Number(paginationParams.page || 1), 1);
+    const pageSize = Math.max(Number(paginationParams.pageSize || 10), 1);
+    const skip = (page - 1) * pageSize;
+    const normalizedSort = sort === 'asc' ? 'asc' : 'desc';
+
+    const where = { webhook_integration_id: integrationId };
+
+    const [data, total] = await Promise.all([
+      this.logs.findMany({
+        where,
+        orderBy: [{ created_at: normalizedSort }, { id: normalizedSort }],
+        skip,
+        take: pageSize,
+      }),
+      this.logs.count({ where }),
+    ]);
+
+    const lastPage = Math.max(1, Math.ceil(total / pageSize));
+    const result = {
+      total,
+      lastPage,
+      page,
+      pageSize,
+      prev: page > 1 ? page - 1 : null,
+      next: page < lastPage ? page + 1 : null,
+      data,
+    };
 
     const logIds = (result.data || [])
       .map((item: any) => item.id)
@@ -303,6 +359,27 @@ export class WebhookIntegrationService {
     };
   }
 
+  streamLogs(integrationId: number, 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();
+
+    res.write(`data: ${JSON.stringify({ type: 'connected' })}\n\n`);
+
+    const handler = (payload: unknown) => {
+      res.write(`data: ${JSON.stringify({ type: 'log', payload })}\n\n`);
+    };
+
+    const eventKey = `log:${integrationId}`;
+    this.logEmitter.on(eventKey, handler);
+
+    res.on('close', () => {
+      this.logEmitter.off(eventKey, handler);
+    });
+  }
+
   async executePublic(uuid: string, body: any, headers: any, req: Request) {
     const startedAt = Date.now();
     const remoteIp = this.getRemoteIp(req);
@@ -372,6 +449,7 @@ export class WebhookIntegrationService {
             actionType: action.type,
             status: 'failed',
             durationMs,
+            requestPayload: this.extractErrorRequestPayload(error),
             errorMessage,
             responsePayload: this.extractErrorResponse(error),
           });
@@ -397,6 +475,10 @@ export class WebhookIntegrationService {
 
       await this.createActionLogs(callLog?.id, actionLogs);
 
+      if (integration?.id && callLog?.id) {
+        this.logEmitter.emit(`log:${integration.id}`, { id: callLog.id });
+      }
+
       return response;
     } catch (error) {
       const callLog = await this.createCallLog({
@@ -421,6 +503,10 @@ export class WebhookIntegrationService {
 
       await this.createActionLogs(callLog?.id, actionLogs).catch(() => undefined);
 
+      if (integration?.id && callLog?.id) {
+        this.logEmitter.emit(`log:${integration.id}`, { id: callLog.id });
+      }
+
       if (error instanceof HttpException) {
         throw error;
       }
@@ -451,11 +537,7 @@ export class WebhookIntegrationService {
   }
 
   private async executeEmailAction(action: any, body: any) {
-    if (!action.mail_profile_id || !action.mail_id || !action.email_to) {
-      throw new BadRequestException(
-        'Email action is missing required configuration.',
-      );
-    }
+    this.validateActionConfiguration(action);
 
     const profile = await (this.prisma as any).mail_profile.findUnique({
       where: { id: Number(action.mail_profile_id) },
@@ -486,14 +568,24 @@ export class WebhookIntegrationService {
         : profile.reply_to_email
       : undefined;
 
+    const renderedTo = String(renderTemplate(action.email_to, body) ?? '').trim();
+    const renderedCc = action.email_cc
+      ? String(renderTemplate(action.email_cc, body) ?? '').trim()
+      : '';
+    const renderedBcc = action.email_bcc
+      ? String(renderTemplate(action.email_bcc, body) ?? '').trim()
+      : '';
+
+    if (!renderedTo) {
+      throw new BadRequestException(
+        'Email action rendered an empty recipient for email_to.',
+      );
+    }
+
     const requestPayload = {
-      to: renderTemplate(action.email_to, body) as string,
-      cc: action.email_cc
-        ? (renderTemplate(action.email_cc, body) as string)
-        : undefined,
-      bcc: action.email_bcc
-        ? (renderTemplate(action.email_bcc, body) as string)
-        : undefined,
+      to: renderedTo,
+      cc: renderedCc || undefined,
+      bcc: renderedBcc || undefined,
       from: sender,
       replyTo,
       subject: renderTemplate(template.subject, body) as string,
@@ -537,32 +629,55 @@ export class WebhookIntegrationService {
     const baseUrl = String(action.whatsapp_base_url).replace(/\/+$/, '');
     const instance = encodeURIComponent(action.whatsapp_instance);
     const url = `${baseUrl}/message/sendText/${instance}`;
-    const message = renderTemplate(action.whatsapp_template, body);
-    const target = renderTemplate(action.whatsapp_target, body);
-
-    const response = await firstValueFrom(
-      this.http.post(
-        url,
-        {
-          number: target,
-          text: message,
-        },
-        {
-          headers: {
-            apikey: action.whatsapp_token,
-            Authorization: `Bearer ${action.whatsapp_token}`,
+    const targetType =
+      action.whatsapp_target_type === 'group' ? 'group' : 'phone';
+    const renderedMessage = String(
+      renderTemplate(action.whatsapp_template, body) ?? '',
+    ).trim();
+    const renderedTarget = String(
+      renderTemplate(action.whatsapp_target, body) ?? '',
+    ).trim();
+
+    if (!renderedMessage) {
+      throw new BadRequestException(
+        'WhatsApp action template rendered an empty message.',
+      );
+    }
+
+    const target = this.normalizeWhatsappTarget(renderedTarget, targetType);
+    const requestPayload = {
+      provider: 'evolution',
+      url,
+      instance: action.whatsapp_instance,
+      targetType,
+      number: target,
+      text: renderedMessage,
+    };
+
+    let response: any;
+    try {
+      response = await firstValueFrom(
+        this.http.post(
+          url,
+          {
+            number: target,
+            text: renderedMessage,
           },
-          timeout: 15000,
-        },
-      ),
-    );
+          {
+            headers: {
+              apikey: action.whatsapp_token,
+            },
+            timeout: 15000,
+          },
+        ),
+      );
+    } catch (error) {
+      this.attachErrorRequestPayload(error, requestPayload);
+      throw error;
+    }
 
     return {
-      requestPayload: {
-        url,
-        number: target,
-        text: message,
-      },
+      requestPayload,
       responsePayload: {
         status: response?.status || null,
         statusText: response?.statusText || null,
@@ -600,6 +715,48 @@ export class WebhookIntegrationService {
     }
   }
 
+  private validateActionConfiguration(action: any) {
+    if (action?.type === 'email') {
+      const missing: string[] = [];
+
+      if (!this.nullableNumber(action.mail_profile_id)) {
+        missing.push('mail_profile_id');
+      }
+
+      if (!this.nullableNumber(action.mail_id)) {
+        missing.push('mail_id');
+      }
+
+      if (!this.nullableString(action.email_to, true)) {
+        missing.push('email_to');
+      }
+
+      if (missing.length) {
+        throw new BadRequestException(
+          `Email action is missing required configuration: ${missing.join(', ')}.`,
+        );
+      }
+    }
+
+    if (action?.type === 'whatsapp_evolution') {
+      const missing = [
+        ['whatsapp_target', action.whatsapp_target],
+        ['whatsapp_template', action.whatsapp_template],
+        ['whatsapp_instance', action.whatsapp_instance],
+        ['whatsapp_base_url', action.whatsapp_base_url],
+        ['whatsapp_token', action.whatsapp_token],
+      ]
+        .filter(([, value]) => !String(value || '').trim())
+        .map(([key]) => key);
+
+      if (missing.length) {
+        throw new BadRequestException(
+          `WhatsApp action is missing required configuration: ${missing.join(', ')}.`,
+        );
+      }
+    }
+  }
+
   private validateBodySchema(integration: any, body: any) {
     if (!integration.body_schema) {
       return;
@@ -777,6 +934,48 @@ export class WebhookIntegrationService {
     };
   }
 
+  private extractErrorRequestPayload(error: unknown) {
+    if (!error || typeof error !== 'object') {
+      return null;
+    }
+
+    const maybePayload = (error as any).__webhookRequestPayload;
+    return maybePayload || null;
+  }
+
+  private attachErrorRequestPayload(error: unknown, requestPayload: unknown) {
+    if (!error || typeof error !== 'object') {
+      return;
+    }
+
+    (error as any).__webhookRequestPayload = requestPayload;
+  }
+
+  private normalizeWhatsappTarget(
+    renderedTarget: string,
+    targetType: 'phone' | 'group',
+  ) {
+    const rawTarget = String(renderedTarget || '').trim();
+    if (!rawTarget) {
+      throw new BadRequestException(
+        'WhatsApp action target template rendered an empty value.',
+      );
+    }
+
+    if (targetType === 'group') {
+      return rawTarget;
+    }
+
+    const normalized = rawTarget.replace(/\D+/g, '');
+    if (!normalized) {
+      throw new BadRequestException(
+        'WhatsApp action target must contain at least one digit for phone targets.',
+      );
+    }
+
+    return normalized;
+  }
+
   private getRemoteIp(req: Request) {
     const forwardedFor = req.headers['x-forwarded-for'];
     const forwardedIp = Array.isArray(forwardedFor)
@@ -835,7 +1034,7 @@ export class WebhookIntegrationService {
     return normalized;
   }
 
-  private normalizeAction(data: any, partial = false) {
+  private normalizeAction(data: WebhookActionPayload, partial = false) {
     const normalized: Record<string, any> = {};
     const assign = (key: string, value: any) => {
       if (!partial || value !== undefined) {
@@ -847,8 +1046,8 @@ export class WebhookIntegrationService {
     assign('name', String(data.name ?? '').trim());
     assign('order', Number(data.order ?? 0));
     assign('status', data.status === 'inactive' ? 'inactive' : 'active');
-    assign('mail_profile_id', this.nullableNumber(data.mail_profile_id));
-    assign('mail_id', this.nullableNumber(data.mail_id));
+    assign('mail_profile_id', this.nullableNumber(data.mail_profile_id, partial));
+    assign('mail_id', this.nullableNumber(data.mail_id, partial));
     assign('email_to', this.nullableString(data.email_to, partial));
     assign('email_cc', this.nullableString(data.email_cc, partial));
     assign('email_bcc', this.nullableString(data.email_bcc, partial));
@@ -887,8 +1086,12 @@ export class WebhookIntegrationService {
     return normalized || null;
   }
 
-  private nullableNumber(value: any) {
-    if (value === undefined || value === null || value === '') {
+  private nullableNumber(value: any, partial = false) {
+    if (value === undefined) {
+      return partial ? undefined : null;
+    }
+
+    if (value === null || value === '') {
       return null;
     }