@hed-hog/core 0.0.355 → 0.0.358

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

@@ -12,12 +12,19 @@ import {
 import { EventEmitter } from 'events';
 import { Request, Response } from 'express';
 import { firstValueFrom } from 'rxjs';
+import {
+    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,
@@ -31,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;
@@ -47,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,
@@ -55,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() {
@@ -84,6 +134,7 @@ export class WebhookIntegrationService {
         where: OR.length > 0 ? { OR } : {},
         include: {
           webhook_action: {
+            select: this.webhookActionSelect,
             orderBy: [{ order: 'asc' }, { id: 'asc' }],
           },
         },
@@ -102,6 +153,7 @@ export class WebhookIntegrationService {
       where: { id },
       include: {
         webhook_action: {
+          select: this.webhookActionSelect,
           orderBy: [{ order: 'asc' }, { id: 'asc' }],
         },
       },
@@ -203,6 +255,82 @@ export class WebhookIntegrationService {
     };
   }
 
+  async duplicate(id: number) {
+    const original = await this.get(id);
+
+    const newSlug = await this.generateUniqueSlug(original.slug, this.integrations);
+
+    let plainToken: string | null = null;
+    let tokenHash: string | null = null;
+    if (original.require_token) {
+      plainToken = createPlainToken();
+      tokenHash = hashToken(plainToken);
+    }
+
+    const record = await this.integrations.create({
+      data: {
+        slug: newSlug,
+        name: `${original.name} (copy)`,
+        description: original.description,
+        public_uuid: createPublicUuid(),
+        status: original.status,
+        require_token: original.require_token,
+        token_hash: tokenHash,
+        allowed_ips: original.allowed_ips,
+        body_schema: original.body_schema,
+        webhook_action: {
+          create: (original.webhook_action ?? []).map((a: any) => ({
+            type: a.type,
+            name: a.name,
+            order: a.order,
+            status: a.status,
+            integration_profile_id:
+              a.integration_profile_id ?? null,
+            mail_id: a.mail_id,
+            email_to: a.email_to,
+            email_cc: a.email_cc,
+            email_bcc: a.email_bcc,
+            whatsapp_target_type: a.whatsapp_target_type,
+            whatsapp_target: a.whatsapp_target,
+            whatsapp_template: a.whatsapp_template,
+            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,
+          })),
+        },
+      },
+    });
+
+    return { ...(await this.withPublicUrl(record)), plainToken };
+  }
+
+  private async generateUniqueSlug(base: string, table: any): Promise<string> {
+    const candidate = `${base}-copy`;
+    const existing = await table.findUnique({ where: { slug: candidate } });
+    if (!existing) return candidate;
+
+    for (let i = 2; ; i++) {
+      const next = `${base}-copy-${i}`;
+      const taken = await table.findUnique({ where: { slug: next } });
+      if (!taken) return next;
+    }
+  }
+
   private async getApplicationBaseUrl() {
     const settings = await this.settingService.getSettingValues([
       'api-url',
@@ -293,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,
@@ -391,6 +561,7 @@ export class WebhookIntegrationService {
         where: { public_uuid: uuid },
         include: {
           webhook_action: {
+            select: this.webhookActionSelect,
             where: { status: 'active' },
             orderBy: [{ order: 'asc' }, { id: 'asc' }],
           },
@@ -533,14 +704,27 @@ 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}`);
   }
 
   private async executeEmailAction(action: any, body: any) {
     this.validateActionConfiguration(action);
 
-    const profile = await (this.prisma as any).mail_profile.findUnique({
-      where: { id: Number(action.mail_profile_id) },
+    const profile = await (this.prisma as any).integration_profile.findUnique({
+      where: { id: Number(action.integration_profile_id) },
+      include: { integration_provider: { select: { slug: true } } },
     });
     const mail = await (this.prisma as any).mail.findUnique({
       where: { id: Number(action.mail_id) },
@@ -558,15 +742,12 @@ export class WebhookIntegrationService {
     }
 
     const template = mail.mail_locale[0];
-    const config = this.buildMailConfig(profile);
-    const sender = profile.from_name
-      ? `${profile.from_name} <${profile.from_email}>`
-      : profile.from_email;
-    const replyTo = profile.reply_to_email
-      ? profile.reply_to_name
-        ? `${profile.reply_to_name} <${profile.reply_to_email}>`
-        : profile.reply_to_email
-      : undefined;
+    const config = buildMailConfigFromIntegration(
+      profile.integration_provider.slug,
+      profile.config,
+    );
+    const sender = getFromAddress(profile.config);
+    const replyTo = getReplyToAddress(profile.config);
 
     const renderedTo = String(renderTemplate(action.email_to, body) ?? '').trim();
     const renderedCc = action.email_cc
@@ -686,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;
@@ -719,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)) {
@@ -755,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) {
@@ -1046,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));
@@ -1069,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;
   }
@@ -1098,40 +1524,5 @@ export class WebhookIntegrationService {
     return Number(value);
   }
 
-  private buildMailConfig(profile: any) {
-    switch (profile.provider) {
-      case 'SMTP':
-        return {
-          global: true,
-          type: 'SMTP',
-          host: profile.smtp_host,
-          port: Number(profile.smtp_port || 587),
-          secure: Boolean(profile.smtp_secure),
-          username: profile.smtp_username || '',
-          password: profile.smtp_password || '',
-        };
-      case 'GMAIL':
-        return {
-          global: true,
-          type: 'GMAIL',
-          clientId: profile.gmail_client_id,
-          clientSecret: profile.gmail_client_secret,
-          refreshToken: profile.gmail_refresh_token,
-          from: profile.from_email,
-        };
-      case 'SES':
-        return {
-          global: true,
-          type: 'SES',
-          region: profile.ses_region,
-          accessKeyId: profile.ses_access_key_id,
-          secretAccessKey: profile.ses_secret_access_key,
-          from: profile.from_email,
-        };
-      default:
-        throw new BadRequestException(
-          `Invalid mail profile provider: ${profile.provider}`,
-        );
-    }
-  }
 }
+

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"}