@hed-hog/core 0.0.356 → 0.0.359

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

@@ -1,45 +1,50 @@
-import { MailModule as MailMainModule } from '@hed-hog/api-mail';
-import { PaginationModule } from '@hed-hog/api-pagination';
-import { PrismaModule } from '@hed-hog/api-prisma';
-import { HttpModule } from '@nestjs/axios';
-import { Module, forwardRef } from '@nestjs/common';
-import { IntegrationModule } from '../integration/integration.module';
-import { MailModule } from '../mail/mail.module';
-import { EventWebhookController } from './event-webhook.controller';
-import { EventWebhookService } from './event-webhook.service';
-import { IntegrationEventCatalogController } from './integration-event-catalog.controller';
-import { IntegrationEventCatalogService } from './integration-event-catalog.service';
-import {
-  PublicWebhookController,
-  WebhookIntegrationController,
-} from './webhook-integration.controller';
-import { WebhookIntegrationService } from './webhook-integration.service';
-
-@Module({
-  imports: [
-    HttpModule,
-    forwardRef(() => PrismaModule),
-    forwardRef(() => PaginationModule),
-    forwardRef(() => IntegrationModule),
-    forwardRef(() => MailModule),
-    forwardRef(() => MailMainModule),
-  ],
-  controllers: [
-    IntegrationEventCatalogController,
-    WebhookIntegrationController,
-    PublicWebhookController,
-    EventWebhookController,
-  ],
-  providers: [
-    IntegrationEventCatalogService,
-    WebhookIntegrationService,
-    EventWebhookService,
-  ],
-  exports: [
-    IntegrationEventCatalogService,
-    WebhookIntegrationService,
-    EventWebhookService,
-  ],
-})
-export class WebhookIntegrationModule {}
-
+import { MailModule as MailMainModule } from '@hed-hog/api-mail';
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { HttpModule } from '@nestjs/axios';
+import { Module, forwardRef } from '@nestjs/common';
+import { IntegrationModule } from '../integration/integration.module';
+import { MailModule } from '../mail/mail.module';
+import { McpModule } from '../mcp/mcp.module';
+import { EventWebhookController } from './event-webhook.controller';
+import { EventWebhookService } from './event-webhook.service';
+import { IntegrationEventCatalogController } from './integration-event-catalog.controller';
+import { IntegrationEventCatalogService } from './integration-event-catalog.service';
+import { WebhookCommandRegistry } from './webhook-command.registry';
+import {
+  PublicWebhookController,
+  WebhookIntegrationController,
+} from './webhook-integration.controller';
+import { WebhookIntegrationService } from './webhook-integration.service';
+
+@Module({
+  imports: [
+    HttpModule,
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+    forwardRef(() => IntegrationModule),
+    forwardRef(() => MailModule),
+    forwardRef(() => MailMainModule),
+    forwardRef(() => McpModule),
+  ],
+  controllers: [
+    IntegrationEventCatalogController,
+    WebhookIntegrationController,
+    PublicWebhookController,
+    EventWebhookController,
+  ],
+  providers: [
+    IntegrationEventCatalogService,
+    WebhookCommandRegistry,
+    WebhookIntegrationService,
+    EventWebhookService,
+  ],
+  exports: [
+    IntegrationEventCatalogService,
+    WebhookCommandRegistry,
+    WebhookIntegrationService,
+    EventWebhookService,
+  ],
+})
+export class WebhookIntegrationModule {}
+

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

@@ -13,16 +13,18 @@ import { EventEmitter } from 'events';
 import { Request, Response } from 'express';
 import { firstValueFrom } from 'rxjs';
 import {
-  buildMailConfigFromIntegration,
-  getFromAddress,
-  getReplyToAddress,
+    buildMailConfigFromIntegration,
+    getFromAddress,
+    getReplyToAddress,
 } from '../integration-profile/integration-profile.utils';
 import { MailService } from '../mail/mail.service';
+import { McpApiKeyService } from '../mcp/mcp-api-key.service';
 import { SettingService } from '../setting/setting.service';
 import {
-  CreateWebhookActionDTO,
-  UpdateWebhookActionDTO,
+    CreateWebhookActionDTO,
+    UpdateWebhookActionDTO,
 } from './dto/webhook-action.dto';
+import { WebhookCommandRegistry } from './webhook-command.registry';
 import {
     createPlainToken,
     createPublicUuid,
@@ -36,7 +38,12 @@ import {
 type ActionExecutionLog = {
   webhookActionId: number;
   actionName: string;
-  actionType: 'email' | 'whatsapp_evolution';
+  actionType:
+    | 'email'
+    | 'whatsapp_evolution'
+    | 'http_request'
+    | 'internal_api'
+    | 'app_command';
   status: 'success' | 'failed';
   durationMs: number;
   requestPayload?: unknown;
@@ -52,6 +59,42 @@ type WebhookActionPayload =
 @Injectable()
 export class WebhookIntegrationService {
   private readonly logEmitter = new EventEmitter();
+  private readonly webhookActionSelect = {
+    id: true,
+    webhook_integration_id: true,
+    type: true,
+    name: true,
+    order: true,
+    status: true,
+    integration_profile_id: true,
+    mail_id: true,
+    email_to: true,
+    email_cc: true,
+    email_bcc: true,
+    whatsapp_target_type: true,
+    whatsapp_target: true,
+    whatsapp_template: true,
+    whatsapp_instance: true,
+    whatsapp_base_url: true,
+    whatsapp_token: true,
+    http_url: true,
+    http_method: true,
+    http_headers: true,
+    http_query: true,
+    http_body: true,
+    http_timeout_ms: true,
+    http_retry_count: true,
+    internal_api_path: true,
+    internal_api_method: true,
+    internal_api_query: true,
+    internal_api_body: true,
+    internal_api_token: true,
+    internal_api_user_id: true,
+    app_command_slug: true,
+    app_command_params: true,
+    created_at: true,
+    updated_at: true,
+  } as const;
 
   constructor(
     private readonly prisma: PrismaService,
@@ -60,6 +103,8 @@ export class WebhookIntegrationService {
     private readonly mailMainService: MailMainService,
     private readonly coreMailService: MailService,
     private readonly settingService: SettingService,
+    private readonly commandRegistry: WebhookCommandRegistry,
+    private readonly mcpApiKeyService: McpApiKeyService,
   ) {}
 
   private get integrations() {
@@ -89,6 +134,7 @@ export class WebhookIntegrationService {
         where: OR.length > 0 ? { OR } : {},
         include: {
           webhook_action: {
+            select: this.webhookActionSelect,
             orderBy: [{ order: 'asc' }, { id: 'asc' }],
           },
         },
@@ -107,6 +153,7 @@ export class WebhookIntegrationService {
       where: { id },
       include: {
         webhook_action: {
+          select: this.webhookActionSelect,
           orderBy: [{ order: 'asc' }, { id: 'asc' }],
         },
       },
@@ -237,7 +284,8 @@ export class WebhookIntegrationService {
             name: a.name,
             order: a.order,
             status: a.status,
-            mail_profile_id: a.mail_profile_id,
+            integration_profile_id:
+              a.integration_profile_id ?? null,
             mail_id: a.mail_id,
             email_to: a.email_to,
             email_cc: a.email_cc,
@@ -248,6 +296,21 @@ export class WebhookIntegrationService {
             whatsapp_instance: a.whatsapp_instance,
             whatsapp_base_url: a.whatsapp_base_url,
             whatsapp_token: a.whatsapp_token,
+            http_url: a.http_url,
+            http_method: a.http_method,
+            http_headers: a.http_headers,
+            http_query: a.http_query,
+            http_body: a.http_body,
+            http_timeout_ms: a.http_timeout_ms,
+            http_retry_count: a.http_retry_count,
+            internal_api_path: a.internal_api_path,
+            internal_api_method: a.internal_api_method,
+            internal_api_query: a.internal_api_query,
+            internal_api_body: a.internal_api_body,
+            internal_api_token: a.internal_api_token,
+            internal_api_user_id: a.internal_api_user_id,
+            app_command_slug: a.app_command_slug,
+            app_command_params: a.app_command_params,
           })),
         },
       },
@@ -358,6 +421,48 @@ export class WebhookIntegrationService {
     });
   }
 
+  async listUserApiTokens(userId: number) {
+    return (this.prisma as any).mcp_api_key.findMany({
+      where: { user_id: userId, type: 'api', revoked_at: null },
+      select: {
+        id: true,
+        name: true,
+        token_prefix: true,
+        last_used_at: true,
+        created_at: true,
+      },
+      orderBy: { created_at: 'desc' },
+    });
+  }
+
+  async createUserApiToken(userId: number, name: string) {
+    return this.mcpApiKeyService.create(userId, name, 'api');
+  }
+
+  async listInternalRoutes() {
+    return (this.prisma as any).route.findMany({
+      select: {
+        id: true,
+        url: true,
+        method: true,
+      },
+      where: {
+        url: { not: null },
+        method: { not: null },
+      },
+      orderBy: [{ url: 'asc' }, { method: 'asc' }],
+    });
+  }
+
+  async listAppCommands() {
+    return this.commandRegistry.list().map((cmd) => ({
+      slug: cmd.slug,
+      name: cmd.name,
+      description: cmd.description,
+      inputSchema: cmd.inputSchema,
+    }));
+  }
+
   async listLogs(
     integrationId: number,
     paginationParams: PaginationDTO,
@@ -456,6 +561,7 @@ export class WebhookIntegrationService {
         where: { public_uuid: uuid },
         include: {
           webhook_action: {
+            select: this.webhookActionSelect,
             where: { status: 'active' },
             orderBy: [{ order: 'asc' }, { id: 'asc' }],
           },
@@ -598,6 +704,18 @@ export class WebhookIntegrationService {
       return this.executeWhatsappAction(action, body);
     }
 
+    if (action.type === 'http_request') {
+      return this.executeHttpRequestAction(action, body);
+    }
+
+    if (action.type === 'internal_api') {
+      return this.executeInternalApiAction(action, body);
+    }
+
+    if (action.type === 'app_command') {
+      return this.executeAppCommandAction(action, body);
+    }
+
     throw new BadRequestException(`Unsupported action type: ${action.type}`);
   }
 
@@ -605,7 +723,7 @@ export class WebhookIntegrationService {
     this.validateActionConfiguration(action);
 
     const profile = await (this.prisma as any).integration_profile.findUnique({
-      where: { id: Number(action.mail_profile_id) },
+      where: { id: Number(action.integration_profile_id) },
       include: { integration_provider: { select: { slug: true } } },
     });
     const mail = await (this.prisma as any).mail.findUnique({
@@ -749,6 +867,193 @@ export class WebhookIntegrationService {
     };
   }
 
+  private async executeHttpRequestAction(action: any, body: any) {
+    this.validateActionConfiguration(action);
+
+    const method = String(action.http_method || 'POST').toUpperCase();
+    const rawUrl = String(action.http_url || '').trim();
+    const timeoutMs = Number(action.http_timeout_ms || 30000);
+    const maxAttempts = Math.max(1, Number(action.http_retry_count || 0) + 1);
+
+    const renderedUrl = String(renderTemplate(rawUrl, body) ?? rawUrl).trim();
+
+    const rawHeaders = normalizeJsonObject(action.http_headers) || {};
+    const renderedHeaders: Record<string, string> = {};
+    for (const [k, v] of Object.entries(rawHeaders)) {
+      renderedHeaders[k] = String(renderTemplate(String(v), body) ?? v);
+    }
+
+    const rawQuery = normalizeJsonObject(action.http_query) || {};
+    const renderedQuery: Record<string, string> = {};
+    for (const [k, v] of Object.entries(rawQuery)) {
+      renderedQuery[k] = String(renderTemplate(String(v), body) ?? v);
+    }
+
+    const rawBody = String(action.http_body || '').trim();
+    const renderedBody = rawBody
+      ? (renderTemplate(rawBody, body) as string)
+      : undefined;
+
+    let parsedBody: unknown = renderedBody;
+    if (renderedBody) {
+      try {
+        parsedBody = JSON.parse(renderedBody);
+      } catch {
+        parsedBody = renderedBody;
+      }
+    }
+
+    const requestPayload = {
+      method,
+      url: renderedUrl,
+      headers: renderedHeaders,
+      query: renderedQuery,
+      body: parsedBody,
+    };
+
+    let lastError: unknown;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const response = await firstValueFrom(
+          this.http.request({
+            method,
+            url: renderedUrl,
+            headers: renderedHeaders,
+            params: Object.keys(renderedQuery).length ? renderedQuery : undefined,
+            data: parsedBody,
+            timeout: timeoutMs,
+          }),
+        );
+
+        return {
+          requestPayload,
+          responsePayload: {
+            status: response?.status || null,
+            statusText: response?.statusText || null,
+            data: response?.data || null,
+          },
+        };
+      } catch (error) {
+        lastError = error;
+        if (attempt === maxAttempts - 1) {
+          this.attachErrorRequestPayload(error, requestPayload);
+          throw error;
+        }
+      }
+    }
+
+    this.attachErrorRequestPayload(lastError, requestPayload);
+    throw lastError;
+  }
+
+  private async executeInternalApiAction(action: any, body: any) {
+    this.validateActionConfiguration(action);
+
+    const baseUrl = await this.getApplicationBaseUrl();
+    if (!baseUrl) {
+      throw new BadRequestException(
+        'Internal API action requires the api-url setting to be configured.',
+      );
+    }
+
+    const method = String(action.internal_api_method || 'POST').toUpperCase();
+    const rawPath = String(action.internal_api_path || '').trim();
+    const token = String(action.internal_api_token || '').trim();
+
+    const renderedPath = String(renderTemplate(rawPath, body) ?? rawPath).trim();
+
+    const rawQuery = normalizeJsonObject(action.internal_api_query) || {};
+    const renderedQuery: Record<string, string> = {};
+    for (const [k, v] of Object.entries(rawQuery)) {
+      renderedQuery[k] = String(renderTemplate(String(v), body) ?? v);
+    }
+
+    const rawBody = normalizeJsonObject(action.internal_api_body) || {};
+    const renderedBodyObj: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(rawBody)) {
+      renderedBodyObj[k] = typeof v === 'string' ? renderTemplate(v, body) : v;
+    }
+
+    const url = `${baseUrl}${renderedPath.startsWith('/') ? '' : '/'}${renderedPath}`;
+
+    const requestPayload = {
+      method,
+      url,
+      query: renderedQuery,
+      body: renderedBodyObj,
+    };
+
+    let response: any;
+    try {
+      response = await firstValueFrom(
+        this.http.request({
+          method,
+          url,
+          headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+          },
+          params: Object.keys(renderedQuery).length ? renderedQuery : undefined,
+          data: Object.keys(renderedBodyObj).length ? renderedBodyObj : undefined,
+          timeout: 30000,
+        }),
+      );
+    } catch (error) {
+      this.attachErrorRequestPayload(error, requestPayload);
+      throw error;
+    }
+
+    return {
+      requestPayload,
+      responsePayload: {
+        status: response?.status || null,
+        statusText: response?.statusText || null,
+        data: response?.data || null,
+      },
+    };
+  }
+
+  private async executeAppCommandAction(action: any, body: any) {
+    this.validateActionConfiguration(action);
+
+    const slug = String(action.app_command_slug || '').trim();
+    const command = this.commandRegistry.find(slug);
+    if (!command) {
+      throw new BadRequestException(`app_command: unknown command slug "${slug}".`);
+    }
+
+    const rawParams = normalizeJsonObject(action.app_command_params) || {};
+    const renderedParams: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(rawParams)) {
+      renderedParams[k] = typeof v === 'string' ? renderTemplate(v, body) : v;
+    }
+
+    const schemaErrors = this.validateJsonSchema(command.inputSchema, renderedParams);
+    if (schemaErrors.length) {
+      throw new BadRequestException({
+        message: `app_command "${slug}" params do not match expected schema.`,
+        errors: schemaErrors,
+      });
+    }
+
+    const requestPayload = { slug, params: renderedParams };
+
+    let result: unknown;
+    try {
+      result = await this.commandRegistry.dispatch(slug, renderedParams, {
+        webhookBody: body,
+      });
+    } catch (error) {
+      this.attachErrorRequestPayload(error, requestPayload);
+      throw error;
+    }
+
+    return {
+      requestPayload,
+      responsePayload: result,
+    };
+  }
+
   private validateToken(integration: any, headers: any) {
     if (!integration.require_token) {
       return;
@@ -782,8 +1087,8 @@ export class WebhookIntegrationService {
     if (action?.type === 'email') {
       const missing: string[] = [];
 
-      if (!this.nullableNumber(action.mail_profile_id)) {
-        missing.push('mail_profile_id');
+      if (!this.nullableNumber(action.integration_profile_id)) {
+        missing.push('integration_profile_id');
       }
 
       if (!this.nullableNumber(action.mail_id)) {
@@ -818,6 +1123,40 @@ export class WebhookIntegrationService {
         );
       }
     }
+
+    if (action?.type === 'http_request') {
+      if (!this.nullableString(action.http_url)) {
+        throw new BadRequestException(
+          'HTTP request action is missing required configuration: http_url.',
+        );
+      }
+    }
+
+    if (action?.type === 'internal_api') {
+      const missing: string[] = [];
+      if (!this.nullableString(action.internal_api_path)) {
+        missing.push('internal_api_path');
+      }
+      if (!this.nullableNumber(action.internal_api_user_id)) {
+        missing.push('internal_api_user_id');
+      }
+      if (!this.nullableString(action.internal_api_token)) {
+        missing.push('internal_api_token');
+      }
+      if (missing.length) {
+        throw new BadRequestException(
+          `Internal API action is missing required configuration: ${missing.join(', ')}.`,
+        );
+      }
+    }
+
+    if (action?.type === 'app_command') {
+      if (!this.nullableString(action.app_command_slug)) {
+        throw new BadRequestException(
+          'App command action is missing required configuration: app_command_slug.',
+        );
+      }
+    }
   }
 
   private validateBodySchema(integration: any, body: any) {
@@ -1109,7 +1448,10 @@ 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, partial));
+    assign(
+      'integration_profile_id',
+      this.nullableNumber((data as any).integration_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));
@@ -1132,6 +1474,27 @@ export class WebhookIntegrationService {
       this.nullableString(data.whatsapp_base_url, partial),
     );
     assign('whatsapp_token', this.nullableString(data.whatsapp_token, partial));
+    assign('http_url', this.nullableString(data.http_url, partial));
+    assign('http_method', this.nullableString(data.http_method, partial));
+    assign('http_headers', normalizeJsonObject(data.http_headers));
+    assign('http_query', normalizeJsonObject(data.http_query));
+    assign('http_body', this.nullableString(data.http_body, partial));
+    assign('http_timeout_ms', this.nullableNumber(data.http_timeout_ms, partial));
+    assign('http_retry_count', this.nullableNumber(data.http_retry_count, partial));
+    assign('internal_api_path', this.nullableString(data.internal_api_path, partial));
+    assign(
+      'internal_api_method',
+      this.nullableString(data.internal_api_method, partial),
+    );
+    assign('internal_api_query', normalizeJsonObject(data.internal_api_query));
+    assign('internal_api_body', normalizeJsonObject(data.internal_api_body));
+    assign('internal_api_token', this.nullableString(data.internal_api_token, partial));
+    assign(
+      'internal_api_user_id',
+      this.nullableNumber(data.internal_api_user_id, partial),
+    );
+    assign('app_command_slug', this.nullableString(data.app_command_slug, partial));
+    assign('app_command_params', normalizeJsonObject(data.app_command_params));
 
     return normalized;
   }

package/dist/mail-profile/dto/create.dto.d.ts

@@ -1,23 +0,0 @@
-declare const providerOptions: readonly ["SMTP", "GMAIL", "SES"];
-export declare class CreateDTO {
-    slug: string;
-    name: string;
-    provider: (typeof providerOptions)[number];
-    from_name?: string;
-    from_email: string;
-    reply_to_name?: string;
-    reply_to_email?: string;
-    smtp_host?: string;
-    smtp_port?: number;
-    smtp_secure?: boolean;
-    smtp_username?: string;
-    smtp_password?: string;
-    gmail_client_id?: string;
-    gmail_client_secret?: string;
-    gmail_refresh_token?: string;
-    ses_access_key_id?: string;
-    ses_secret_access_key?: string;
-    ses_region?: string;
-}
-export {};
-//# sourceMappingURL=create.dto.d.ts.map

package/dist/mail-profile/dto/create.dto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.dto.d.ts","sourceRoot":"","sources":["../../../src/mail-profile/dto/create.dto.ts"],"names":[],"mappings":"AAaA,QAAA,MAAM,eAAe,mCAAoC,CAAC;AAE1D,qBAAa,SAAS;IAIpB,IAAI,EAAE,MAAM,CAAC;IAKb,IAAI,EAAE,MAAM,CAAC;IAIb,QAAQ,EAAE,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;IAQ3C,SAAS,CAAC,EAAE,MAAM,CAAC;IAKnB,UAAU,EAAE,MAAM,CAAC;IAQnB,aAAa,CAAC,EAAE,MAAM,CAAC;IAQvB,cAAc,CAAC,EAAE,MAAM,CAAC;IAQxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAQnB,SAAS,CAAC,EAAE,MAAM,CAAC;IAOnB,WAAW,CAAC,EAAE,OAAO,CAAC;IAQtB,aAAa,CAAC,EAAE,MAAM,CAAC;IAQvB,aAAa,CAAC,EAAE,MAAM,CAAC;IAQvB,eAAe,CAAC,EAAE,MAAM,CAAC;IAQzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAO7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAQ7B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAQ3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAQ/B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}