@hed-hog/core 0.0.355 → 0.0.358

package/dist/webhook-integration/webhook-integration.service.js

@@ -17,18 +17,59 @@ const axios_1 = require("@nestjs/axios");
 const common_1 = require("@nestjs/common");
 const events_1 = require("events");
 const rxjs_1 = require("rxjs");
+const integration_profile_utils_1 = require("../integration-profile/integration-profile.utils");
 const mail_service_1 = require("../mail/mail.service");
+const mcp_api_key_service_1 = require("../mcp/mcp-api-key.service");
 const setting_service_1 = require("../setting/setting.service");
+const webhook_command_registry_1 = require("./webhook-command.registry");
 const webhook_utils_1 = require("./webhook-utils");
 let WebhookIntegrationService = class WebhookIntegrationService {
-    constructor(prisma, pagination, http, mailMainService, coreMailService, settingService) {
+    constructor(prisma, pagination, http, mailMainService, coreMailService, settingService, commandRegistry, mcpApiKeyService) {
         this.prisma = prisma;
         this.pagination = pagination;
         this.http = http;
         this.mailMainService = mailMainService;
         this.coreMailService = coreMailService;
         this.settingService = settingService;
+        this.commandRegistry = commandRegistry;
+        this.mcpApiKeyService = mcpApiKeyService;
         this.logEmitter = new events_1.EventEmitter();
+        this.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,
+        };
     }
     get integrations() {
         return this.prisma.webhook_integration;
@@ -49,6 +90,7 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             where: OR.length > 0 ? { OR } : {},
             include: {
                 webhook_action: {
+                    select: this.webhookActionSelect,
                     orderBy: [{ order: 'asc' }, { id: 'asc' }],
                 },
             },
@@ -61,6 +103,7 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             where: { id },
             include: {
                 webhook_action: {
+                    select: this.webhookActionSelect,
                     orderBy: [{ order: 'asc' }, { id: 'asc' }],
                 },
             },
@@ -130,6 +173,80 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         });
         return Object.assign(Object.assign({}, (await this.withPublicUrl(record))), { plainToken });
     }
+    async duplicate(id) {
+        var _a;
+        const original = await this.get(id);
+        const newSlug = await this.generateUniqueSlug(original.slug, this.integrations);
+        let plainToken = null;
+        let tokenHash = null;
+        if (original.require_token) {
+            plainToken = (0, webhook_utils_1.createPlainToken)();
+            tokenHash = (0, webhook_utils_1.hashToken)(plainToken);
+        }
+        const record = await this.integrations.create({
+            data: {
+                slug: newSlug,
+                name: `${original.name} (copy)`,
+                description: original.description,
+                public_uuid: (0, webhook_utils_1.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: ((_a = original.webhook_action) !== null && _a !== void 0 ? _a : []).map((a) => {
+                        var _a;
+                        return ({
+                            type: a.type,
+                            name: a.name,
+                            order: a.order,
+                            status: a.status,
+                            integration_profile_id: (_a = a.integration_profile_id) !== null && _a !== void 0 ? _a : 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 Object.assign(Object.assign({}, (await this.withPublicUrl(record))), { plainToken });
+    }
+    async generateUniqueSlug(base, table) {
+        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;
+        }
+    }
     async getApplicationBaseUrl() {
         const settings = await this.settingService.getSettingValues([
             'api-url',
@@ -187,6 +304,44 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             },
         });
     }
+    async listUserApiTokens(userId) {
+        return this.prisma.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, name) {
+        return this.mcpApiKeyService.create(userId, name, 'api');
+    }
+    async listInternalRoutes() {
+        return this.prisma.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, paginationParams, sort = 'desc') {
         await this.get(integrationId);
         const page = Math.max(Number(paginationParams.page || 1), 1);
@@ -259,6 +414,7 @@ let WebhookIntegrationService = class WebhookIntegrationService {
                 where: { public_uuid: uuid },
                 include: {
                     webhook_action: {
+                        select: this.webhookActionSelect,
                         where: { status: 'active' },
                         orderBy: [{ order: 'asc' }, { id: 'asc' }],
                     },
@@ -382,13 +538,23 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         if (action.type === 'whatsapp_evolution') {
             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 common_1.BadRequestException(`Unsupported action type: ${action.type}`);
     }
     async executeEmailAction(action, body) {
         var _a, _b, _c, _d;
         this.validateActionConfiguration(action);
-        const profile = await this.prisma.mail_profile.findUnique({
-            where: { id: Number(action.mail_profile_id) },
+        const profile = await this.prisma.integration_profile.findUnique({
+            where: { id: Number(action.integration_profile_id) },
+            include: { integration_provider: { select: { slug: true } } },
         });
         const mail = await this.prisma.mail.findUnique({
             where: { id: Number(action.mail_id) },
@@ -402,15 +568,9 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             throw new common_1.BadRequestException('Email action references an invalid profile or template.');
         }
         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 = (0, integration_profile_utils_1.buildMailConfigFromIntegration)(profile.integration_provider.slug, profile.config);
+        const sender = (0, integration_profile_utils_1.getFromAddress)(profile.config);
+        const replyTo = (0, integration_profile_utils_1.getReplyToAddress)(profile.config);
         const renderedTo = String((_b = (0, webhook_utils_1.renderTemplate)(action.email_to, body)) !== null && _b !== void 0 ? _b : '').trim();
         const renderedCc = action.email_cc
             ? String((_c = (0, webhook_utils_1.renderTemplate)(action.email_cc, body)) !== null && _c !== void 0 ? _c : '').trim()
@@ -501,6 +661,165 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             },
         };
     }
+    async executeHttpRequestAction(action, body) {
+        var _a, _b, _c;
+        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((_a = (0, webhook_utils_1.renderTemplate)(rawUrl, body)) !== null && _a !== void 0 ? _a : rawUrl).trim();
+        const rawHeaders = (0, webhook_utils_1.normalizeJsonObject)(action.http_headers) || {};
+        const renderedHeaders = {};
+        for (const [k, v] of Object.entries(rawHeaders)) {
+            renderedHeaders[k] = String((_b = (0, webhook_utils_1.renderTemplate)(String(v), body)) !== null && _b !== void 0 ? _b : v);
+        }
+        const rawQuery = (0, webhook_utils_1.normalizeJsonObject)(action.http_query) || {};
+        const renderedQuery = {};
+        for (const [k, v] of Object.entries(rawQuery)) {
+            renderedQuery[k] = String((_c = (0, webhook_utils_1.renderTemplate)(String(v), body)) !== null && _c !== void 0 ? _c : v);
+        }
+        const rawBody = String(action.http_body || '').trim();
+        const renderedBody = rawBody
+            ? (0, webhook_utils_1.renderTemplate)(rawBody, body)
+            : undefined;
+        let parsedBody = renderedBody;
+        if (renderedBody) {
+            try {
+                parsedBody = JSON.parse(renderedBody);
+            }
+            catch (_d) {
+                parsedBody = renderedBody;
+            }
+        }
+        const requestPayload = {
+            method,
+            url: renderedUrl,
+            headers: renderedHeaders,
+            query: renderedQuery,
+            body: parsedBody,
+        };
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const response = await (0, rxjs_1.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 === null || response === void 0 ? void 0 : response.status) || null,
+                        statusText: (response === null || response === void 0 ? void 0 : response.statusText) || null,
+                        data: (response === null || response === void 0 ? void 0 : response.data) || null,
+                    },
+                };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt === maxAttempts - 1) {
+                    this.attachErrorRequestPayload(error, requestPayload);
+                    throw error;
+                }
+            }
+        }
+        this.attachErrorRequestPayload(lastError, requestPayload);
+        throw lastError;
+    }
+    async executeInternalApiAction(action, body) {
+        var _a, _b;
+        this.validateActionConfiguration(action);
+        const baseUrl = await this.getApplicationBaseUrl();
+        if (!baseUrl) {
+            throw new common_1.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((_a = (0, webhook_utils_1.renderTemplate)(rawPath, body)) !== null && _a !== void 0 ? _a : rawPath).trim();
+        const rawQuery = (0, webhook_utils_1.normalizeJsonObject)(action.internal_api_query) || {};
+        const renderedQuery = {};
+        for (const [k, v] of Object.entries(rawQuery)) {
+            renderedQuery[k] = String((_b = (0, webhook_utils_1.renderTemplate)(String(v), body)) !== null && _b !== void 0 ? _b : v);
+        }
+        const rawBody = (0, webhook_utils_1.normalizeJsonObject)(action.internal_api_body) || {};
+        const renderedBodyObj = {};
+        for (const [k, v] of Object.entries(rawBody)) {
+            renderedBodyObj[k] = typeof v === 'string' ? (0, webhook_utils_1.renderTemplate)(v, body) : v;
+        }
+        const url = `${baseUrl}${renderedPath.startsWith('/') ? '' : '/'}${renderedPath}`;
+        const requestPayload = {
+            method,
+            url,
+            query: renderedQuery,
+            body: renderedBodyObj,
+        };
+        let response;
+        try {
+            response = await (0, rxjs_1.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 === null || response === void 0 ? void 0 : response.status) || null,
+                statusText: (response === null || response === void 0 ? void 0 : response.statusText) || null,
+                data: (response === null || response === void 0 ? void 0 : response.data) || null,
+            },
+        };
+    }
+    async executeAppCommandAction(action, body) {
+        this.validateActionConfiguration(action);
+        const slug = String(action.app_command_slug || '').trim();
+        const command = this.commandRegistry.find(slug);
+        if (!command) {
+            throw new common_1.BadRequestException(`app_command: unknown command slug "${slug}".`);
+        }
+        const rawParams = (0, webhook_utils_1.normalizeJsonObject)(action.app_command_params) || {};
+        const renderedParams = {};
+        for (const [k, v] of Object.entries(rawParams)) {
+            renderedParams[k] = typeof v === 'string' ? (0, webhook_utils_1.renderTemplate)(v, body) : v;
+        }
+        const schemaErrors = this.validateJsonSchema(command.inputSchema, renderedParams);
+        if (schemaErrors.length) {
+            throw new common_1.BadRequestException({
+                message: `app_command "${slug}" params do not match expected schema.`,
+                errors: schemaErrors,
+            });
+        }
+        const requestPayload = { slug, params: renderedParams };
+        let result;
+        try {
+            result = await this.commandRegistry.dispatch(slug, renderedParams, {
+                webhookBody: body,
+            });
+        }
+        catch (error) {
+            this.attachErrorRequestPayload(error, requestPayload);
+            throw error;
+        }
+        return {
+            requestPayload,
+            responsePayload: result,
+        };
+    }
     validateToken(integration, headers) {
         var _a;
         if (!integration.require_token) {
@@ -527,8 +846,8 @@ let WebhookIntegrationService = class WebhookIntegrationService {
     validateActionConfiguration(action) {
         if ((action === null || action === void 0 ? void 0 : action.type) === 'email') {
             const missing = [];
-            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)) {
                 missing.push('mail_id');
@@ -554,6 +873,31 @@ let WebhookIntegrationService = class WebhookIntegrationService {
                 throw new common_1.BadRequestException(`WhatsApp action is missing required configuration: ${missing.join(', ')}.`);
             }
         }
+        if ((action === null || action === void 0 ? void 0 : action.type) === 'http_request') {
+            if (!this.nullableString(action.http_url)) {
+                throw new common_1.BadRequestException('HTTP request action is missing required configuration: http_url.');
+            }
+        }
+        if ((action === null || action === void 0 ? void 0 : action.type) === 'internal_api') {
+            const missing = [];
+            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 common_1.BadRequestException(`Internal API action is missing required configuration: ${missing.join(', ')}.`);
+            }
+        }
+        if ((action === null || action === void 0 ? void 0 : action.type) === 'app_command') {
+            if (!this.nullableString(action.app_command_slug)) {
+                throw new common_1.BadRequestException('App command action is missing required configuration: app_command_slug.');
+            }
+        }
     }
     validateBodySchema(integration, body) {
         if (!integration.body_schema) {
@@ -772,7 +1116,7 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         assign('name', String((_a = data.name) !== null && _a !== void 0 ? _a : '').trim());
         assign('order', Number((_b = data.order) !== null && _b !== void 0 ? _b : 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.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));
@@ -783,6 +1127,21 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         assign('whatsapp_instance', this.nullableString(data.whatsapp_instance, partial));
         assign('whatsapp_base_url', 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', (0, webhook_utils_1.normalizeJsonObject)(data.http_headers));
+        assign('http_query', (0, webhook_utils_1.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', (0, webhook_utils_1.normalizeJsonObject)(data.internal_api_query));
+        assign('internal_api_body', (0, webhook_utils_1.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', (0, webhook_utils_1.normalizeJsonObject)(data.app_command_params));
         return normalized;
     }
     nullableString(value, partial = false) {
@@ -804,40 +1163,6 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         }
         return Number(value);
     }
-    buildMailConfig(profile) {
-        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 common_1.BadRequestException(`Invalid mail profile provider: ${profile.provider}`);
-        }
-    }
 };
 exports.WebhookIntegrationService = WebhookIntegrationService;
 exports.WebhookIntegrationService = WebhookIntegrationService = __decorate([
@@ -847,6 +1172,8 @@ exports.WebhookIntegrationService = WebhookIntegrationService = __decorate([
         axios_1.HttpService,
         api_mail_1.MailService,
         mail_service_1.MailService,
-        setting_service_1.SettingService])
+        setting_service_1.SettingService,
+        webhook_command_registry_1.WebhookCommandRegistry,
+        mcp_api_key_service_1.McpApiKeyService])
 ], WebhookIntegrationService);
 //# sourceMappingURL=webhook-integration.service.js.map