@hed-hog/core 0.0.349 → 0.0.351

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

@@ -15,6 +15,7 @@ const api_pagination_1 = require("@hed-hog/api-pagination");
 const api_prisma_1 = require("@hed-hog/api-prisma");
 const axios_1 = require("@nestjs/axios");
 const common_1 = require("@nestjs/common");
+const events_1 = require("events");
 const rxjs_1 = require("rxjs");
 const mail_service_1 = require("../mail/mail.service");
 const setting_service_1 = require("../setting/setting.service");
@@ -27,6 +28,7 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         this.mailMainService = mailMainService;
         this.coreMailService = coreMailService;
         this.settingService = settingService;
+        this.logEmitter = new events_1.EventEmitter();
     }
     get integrations() {
         return this.prisma.webhook_integration;
@@ -37,6 +39,9 @@ let WebhookIntegrationService = class WebhookIntegrationService {
     get logs() {
         return this.prisma.webhook_call_log;
     }
+    get actionLogs() {
+        return this.prisma.webhook_action_log;
+    }
     async list(paginationParams) {
         const fields = ['slug', 'name', 'description', 'public_uuid', 'status'];
         const OR = this.prisma.createInsensitiveSearch(fields, paginationParams);
@@ -126,8 +131,11 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         return Object.assign(Object.assign({}, (await this.withPublicUrl(record))), { plainToken });
     }
     async getApplicationBaseUrl() {
-        const settings = await this.settingService.getSettingValues('url');
-        const value = settings === null || settings === void 0 ? void 0 : settings.url;
+        const settings = await this.settingService.getSettingValues([
+            'api-url',
+            'url',
+        ]);
+        const value = (settings === null || settings === void 0 ? void 0 : settings['api-url']) || (settings === null || settings === void 0 ? void 0 : settings.url);
         return typeof value === 'string' ? value.replace(/\/+$/, '') : '';
     }
     async withPublicUrl(record) {
@@ -151,15 +159,19 @@ let WebhookIntegrationService = class WebhookIntegrationService {
     }
     async createAction(integrationId, data) {
         await this.get(integrationId);
+        const normalized = this.normalizeAction(data);
+        this.validateActionConfiguration(normalized);
         return this.actions.create({
-            data: Object.assign(Object.assign({}, this.normalizeAction(data)), { webhook_integration_id: integrationId }),
+            data: Object.assign(Object.assign({}, normalized), { webhook_integration_id: integrationId }),
         });
     }
     async updateAction(integrationId, actionId, data) {
-        await this.ensureAction(integrationId, actionId);
+        const existing = await this.ensureAction(integrationId, actionId);
+        const normalized = this.normalizeAction(data, true);
+        this.validateActionConfiguration(Object.assign(Object.assign({}, existing), normalized));
         return this.actions.update({
             where: { id: actionId },
-            data: this.normalizeAction(data, true),
+            data: normalized,
         });
     }
     async deleteActions(integrationId, data) {
@@ -175,16 +187,72 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             },
         });
     }
-    async listLogs(integrationId, paginationParams) {
+    async listLogs(integrationId, paginationParams, sort = 'desc') {
         await this.get(integrationId);
-        return 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) => item.id)
+            .filter((id) => typeof id === 'number');
+        if (!logIds.length || !this.actionLogs) {
+            return result;
+        }
+        const actionLogs = await this.actionLogs.findMany({
+            where: {
+                webhook_call_log_id: { in: logIds },
+            },
+            orderBy: [{ created_at: 'asc' }, { id: 'asc' }],
+        });
+        const actionLogsByCallId = new Map();
+        for (const actionLog of actionLogs || []) {
+            const list = actionLogsByCallId.get(actionLog.webhook_call_log_id) || [];
+            list.push(actionLog);
+            actionLogsByCallId.set(actionLog.webhook_call_log_id, list);
+        }
+        return Object.assign(Object.assign({}, result), { data: (result.data || []).map((item) => (Object.assign(Object.assign({}, item), { webhook_action_log: actionLogsByCallId.get(item.id) || [] }))) });
+    }
+    streamLogs(integrationId, res) {
+        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) => {
+            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, body, headers, req) {
         const startedAt = Date.now();
         const remoteIp = this.getRemoteIp(req);
+        const actionLogs = [];
         let integration = null;
         try {
             integration = await this.integrations.findUnique({
@@ -204,13 +272,56 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             this.validateBodySchema(integration, body);
             const actionResults = [];
             for (const action of integration.webhook_action || []) {
-                actionResults.push(await this.executeAction(action, body));
+                const actionStartedAt = Date.now();
+                try {
+                    const result = await this.executeAction(action, body);
+                    const durationMs = Date.now() - actionStartedAt;
+                    actionResults.push({
+                        id: action.id,
+                        type: action.type,
+                        success: true,
+                        duration_ms: durationMs,
+                        response: (0, webhook_utils_1.summarizePayload)(result.responsePayload),
+                    });
+                    actionLogs.push({
+                        webhookActionId: action.id,
+                        actionName: action.name,
+                        actionType: action.type,
+                        status: 'success',
+                        durationMs,
+                        requestPayload: result.requestPayload,
+                        responsePayload: result.responsePayload,
+                    });
+                }
+                catch (error) {
+                    const durationMs = Date.now() - actionStartedAt;
+                    const errorMessage = this.extractErrorMessage(error);
+                    actionResults.push({
+                        id: action.id,
+                        type: action.type,
+                        success: false,
+                        duration_ms: durationMs,
+                        error: errorMessage,
+                        response: (0, webhook_utils_1.summarizePayload)(this.extractErrorResponse(error)),
+                    });
+                    actionLogs.push({
+                        webhookActionId: action.id,
+                        actionName: action.name,
+                        actionType: action.type,
+                        status: 'failed',
+                        durationMs,
+                        requestPayload: this.extractErrorRequestPayload(error),
+                        errorMessage,
+                        responsePayload: this.extractErrorResponse(error),
+                    });
+                    throw error;
+                }
             }
             const response = {
                 success: true,
                 actions: actionResults,
             };
-            await this.createCallLog({
+            const callLog = await this.createCallLog({
                 integration,
                 uuid,
                 status: 'success',
@@ -219,37 +330,63 @@ let WebhookIntegrationService = class WebhookIntegrationService {
                 payload: body,
                 response,
             });
+            await this.createActionLogs(callLog === null || callLog === void 0 ? void 0 : callLog.id, actionLogs);
+            if ((integration === null || integration === void 0 ? void 0 : integration.id) && (callLog === null || callLog === void 0 ? void 0 : callLog.id)) {
+                this.logEmitter.emit(`log:${integration.id}`, { id: callLog.id });
+            }
             return response;
         }
         catch (error) {
-            await this.createCallLog({
+            const callLog = await this.createCallLog({
                 integration,
                 uuid,
                 status: 'failed',
                 remoteIp,
                 durationMs: Date.now() - startedAt,
                 payload: body,
+                response: {
+                    success: false,
+                    actions: actionLogs.map((item) => ({
+                        id: item.webhookActionId,
+                        type: item.actionType,
+                        success: item.status === 'success',
+                        duration_ms: item.durationMs,
+                        error: item.errorMessage || null,
+                    })),
+                },
                 error,
-            });
-            throw error;
+            }).catch(() => null);
+            await this.createActionLogs(callLog === null || callLog === void 0 ? void 0 : callLog.id, actionLogs).catch(() => undefined);
+            if ((integration === null || integration === void 0 ? void 0 : integration.id) && (callLog === null || callLog === void 0 ? void 0 : callLog.id)) {
+                this.logEmitter.emit(`log:${integration.id}`, { id: callLog.id });
+            }
+            if (error instanceof common_1.HttpException) {
+                throw error;
+            }
+            return {
+                success: false,
+                actions: actionLogs.map((item) => ({
+                    id: item.webhookActionId,
+                    type: item.actionType,
+                    success: item.status === 'success',
+                    duration_ms: item.durationMs,
+                    error: item.errorMessage || null,
+                })),
+            };
         }
     }
     async executeAction(action, body) {
         if (action.type === 'email') {
-            await this.executeEmailAction(action, body);
-            return { id: action.id, type: action.type, success: true };
+            return this.executeEmailAction(action, body);
         }
         if (action.type === 'whatsapp_evolution') {
-            await this.executeWhatsappAction(action, body);
-            return { id: action.id, type: action.type, success: true };
+            return this.executeWhatsappAction(action, body);
         }
         throw new common_1.BadRequestException(`Unsupported action type: ${action.type}`);
     }
     async executeEmailAction(action, body) {
-        var _a;
-        if (!action.mail_profile_id || !action.mail_id || !action.email_to) {
-            throw new common_1.BadRequestException('Email action is missing required configuration.');
-        }
+        var _a, _b, _c, _d;
+        this.validateActionConfiguration(action);
         const profile = await this.prisma.mail_profile.findUnique({
             where: { id: Number(action.mail_profile_id) },
         });
@@ -274,28 +411,43 @@ let WebhookIntegrationService = class WebhookIntegrationService {
                 ? `${profile.reply_to_name} <${profile.reply_to_email}>`
                 : profile.reply_to_email
             : undefined;
+        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()
+            : '';
+        const renderedBcc = action.email_bcc
+            ? String((_d = (0, webhook_utils_1.renderTemplate)(action.email_bcc, body)) !== null && _d !== void 0 ? _d : '').trim()
+            : '';
+        if (!renderedTo) {
+            throw new common_1.BadRequestException('Email action rendered an empty recipient for email_to.');
+        }
+        const requestPayload = {
+            to: renderedTo,
+            cc: renderedCc || undefined,
+            bcc: renderedBcc || undefined,
+            from: sender,
+            replyTo,
+            subject: (0, webhook_utils_1.renderTemplate)(template.subject, body),
+            body: (0, webhook_utils_1.renderTemplate)(template.body, body),
+            mail_id: mail.id,
+        };
         try {
             this.mailMainService.setConfig(config);
-            await this.mailMainService.send({
-                to: (0, webhook_utils_1.renderTemplate)(action.email_to, body),
-                cc: action.email_cc
-                    ? (0, webhook_utils_1.renderTemplate)(action.email_cc, body)
-                    : undefined,
-                bcc: action.email_bcc
-                    ? (0, webhook_utils_1.renderTemplate)(action.email_bcc, body)
-                    : undefined,
-                from: sender,
-                replyTo,
-                subject: (0, webhook_utils_1.renderTemplate)(template.subject, body),
-                body: (0, webhook_utils_1.renderTemplate)(template.body, body),
-                mail_id: mail.id,
-            });
+            const providerResponse = await this.mailMainService.send(requestPayload);
+            return {
+                requestPayload,
+                responsePayload: {
+                    provider: 'email',
+                    response: providerResponse || null,
+                },
+            };
         }
         finally {
             await this.coreMailService.reloadConfig().catch(() => undefined);
         }
     }
     async executeWhatsappAction(action, body) {
+        var _a, _b;
         const required = [
             action.whatsapp_target,
             action.whatsapp_template,
@@ -309,18 +461,45 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         const baseUrl = String(action.whatsapp_base_url).replace(/\/+$/, '');
         const instance = encodeURIComponent(action.whatsapp_instance);
         const url = `${baseUrl}/message/sendText/${instance}`;
-        const message = (0, webhook_utils_1.renderTemplate)(action.whatsapp_template, body);
-        const target = (0, webhook_utils_1.renderTemplate)(action.whatsapp_target, body);
-        await (0, rxjs_1.firstValueFrom)(this.http.post(url, {
+        const targetType = action.whatsapp_target_type === 'group' ? 'group' : 'phone';
+        const renderedMessage = String((_a = (0, webhook_utils_1.renderTemplate)(action.whatsapp_template, body)) !== null && _a !== void 0 ? _a : '').trim();
+        const renderedTarget = String((_b = (0, webhook_utils_1.renderTemplate)(action.whatsapp_target, body)) !== null && _b !== void 0 ? _b : '').trim();
+        if (!renderedMessage) {
+            throw new common_1.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: message,
-        }, {
-            headers: {
-                apikey: action.whatsapp_token,
-                Authorization: `Bearer ${action.whatsapp_token}`,
+            text: renderedMessage,
+        };
+        let response;
+        try {
+            response = await (0, rxjs_1.firstValueFrom)(this.http.post(url, {
+                number: target,
+                text: renderedMessage,
+            }, {
+                headers: {
+                    apikey: action.whatsapp_token,
+                },
+                timeout: 15000,
+            }));
+        }
+        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,
             },
-            timeout: 15000,
-        }));
+        };
     }
     validateToken(integration, headers) {
         var _a;
@@ -345,6 +524,37 @@ let WebhookIntegrationService = class WebhookIntegrationService {
             throw new common_1.BadRequestException('Remote IP is not allowed.');
         }
     }
+    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.mail_id)) {
+                missing.push('mail_id');
+            }
+            if (!this.nullableString(action.email_to, true)) {
+                missing.push('email_to');
+            }
+            if (missing.length) {
+                throw new common_1.BadRequestException(`Email action is missing required configuration: ${missing.join(', ')}.`);
+            }
+        }
+        if ((action === null || action === void 0 ? void 0 : 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 common_1.BadRequestException(`WhatsApp action is missing required configuration: ${missing.join(', ')}.`);
+            }
+        }
+    }
     validateBodySchema(integration, body) {
         if (!integration.body_schema) {
             return;
@@ -416,25 +626,95 @@ let WebhookIntegrationService = class WebhookIntegrationService {
     async createCallLog(input) {
         var _a, _b;
         if (!this.logs) {
-            return;
+            return null;
         }
-        await this.logs.create({
+        return this.logs.create({
             data: {
                 webhook_integration_id: (_b = (_a = input.integration) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null,
                 public_uuid: input.uuid,
                 status: input.status,
                 remote_ip: input.remoteIp,
                 duration_ms: input.durationMs,
-                error_message: input.error
-                    ? input.error instanceof Error
-                        ? input.error.message
-                        : String(input.error)
-                    : null,
-                payload_summary: (0, webhook_utils_1.summarizePayload)(input.payload),
-                response_summary: (0, webhook_utils_1.summarizePayload)(input.response),
+                error_message: input.error ? this.extractErrorMessage(input.error) : null,
+                payload_summary: (0, webhook_utils_1.summarizePayload)((0, webhook_utils_1.sanitizeSensitiveData)(input.payload)),
+                response_summary: (0, webhook_utils_1.summarizePayload)((0, webhook_utils_1.sanitizeSensitiveData)(input.response)),
+            },
+            select: {
+                id: true,
             },
         });
     }
+    async createActionLogs(callLogId, logs) {
+        if (!callLogId || !logs.length || !this.actionLogs) {
+            return;
+        }
+        await this.actionLogs.createMany({
+            data: logs.map((item) => ({
+                webhook_call_log_id: callLogId,
+                webhook_action_id: item.webhookActionId,
+                action_name: item.actionName,
+                action_type: item.actionType,
+                status: item.status,
+                duration_ms: item.durationMs,
+                request_payload: (0, webhook_utils_1.summarizePayload)((0, webhook_utils_1.sanitizeSensitiveData)(item.requestPayload)),
+                response_payload: (0, webhook_utils_1.summarizePayload)((0, webhook_utils_1.sanitizeSensitiveData)(item.responsePayload)),
+                error_message: item.errorMessage || null,
+            })),
+        });
+    }
+    extractErrorMessage(error) {
+        if (!error) {
+            return 'Unknown error';
+        }
+        if (error instanceof Error && error.message) {
+            return error.message;
+        }
+        if (typeof error === 'object' && error.message) {
+            return String(error.message);
+        }
+        return String(error);
+    }
+    extractErrorResponse(error) {
+        if (!error || typeof error !== 'object') {
+            return null;
+        }
+        const maybeResponse = error.response;
+        if (!maybeResponse) {
+            return null;
+        }
+        return {
+            status: maybeResponse.status || null,
+            statusText: maybeResponse.statusText || null,
+            data: maybeResponse.data || null,
+        };
+    }
+    extractErrorRequestPayload(error) {
+        if (!error || typeof error !== 'object') {
+            return null;
+        }
+        const maybePayload = error.__webhookRequestPayload;
+        return maybePayload || null;
+    }
+    attachErrorRequestPayload(error, requestPayload) {
+        if (!error || typeof error !== 'object') {
+            return;
+        }
+        error.__webhookRequestPayload = requestPayload;
+    }
+    normalizeWhatsappTarget(renderedTarget, targetType) {
+        const rawTarget = String(renderedTarget || '').trim();
+        if (!rawTarget) {
+            throw new common_1.BadRequestException('WhatsApp action target template rendered an empty value.');
+        }
+        if (targetType === 'group') {
+            return rawTarget;
+        }
+        const normalized = rawTarget.replace(/\D+/g, '');
+        if (!normalized) {
+            throw new common_1.BadRequestException('WhatsApp action target must contain at least one digit for phone targets.');
+        }
+        return normalized;
+    }
     getRemoteIp(req) {
         const forwardedFor = req.headers['x-forwarded-for'];
         const forwardedIp = Array.isArray(forwardedFor)
@@ -492,8 +772,8 @@ 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));
-        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));
@@ -515,8 +795,11 @@ let WebhookIntegrationService = class WebhookIntegrationService {
         const normalized = String(value).trim();
         return normalized || null;
     }
-    nullableNumber(value) {
-        if (value === undefined || value === null || value === '') {
+    nullableNumber(value, partial = false) {
+        if (value === undefined) {
+            return partial ? undefined : null;
+        }
+        if (value === null || value === '') {
             return null;
         }
         return Number(value);