@atom8n/n8n 2.4.7 → 2.5.1

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination-from-db.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageEventBusDestinationFromDb = messageEventBusDestinationFromDb;
+const backend_common_1 = require("@n8n/backend-common");
+const di_1 = require("@n8n/di");
+const message_event_bus_destination_sentry_ee_1 = require("./message-event-bus-destination-sentry.ee");
+const message_event_bus_destination_syslog_ee_1 = require("./message-event-bus-destination-syslog.ee");
+const message_event_bus_destination_webhook_ee_1 = require("./message-event-bus-destination-webhook.ee");
+function messageEventBusDestinationFromDb(eventBusInstance, dbData) {
+    const destinationData = dbData.destination;
+    if ('__type' in destinationData) {
+        switch (destinationData.__type) {
+            case "$$MessageEventBusDestinationSentry":
+                return message_event_bus_destination_sentry_ee_1.MessageEventBusDestinationSentry.deserialize(eventBusInstance, destinationData);
+            case "$$MessageEventBusDestinationSyslog":
+                return message_event_bus_destination_syslog_ee_1.MessageEventBusDestinationSyslog.deserialize(eventBusInstance, destinationData);
+            case "$$MessageEventBusDestinationWebhook":
+                return message_event_bus_destination_webhook_ee_1.MessageEventBusDestinationWebhook.deserialize(eventBusInstance, destinationData);
+            default:
+                di_1.Container.get(backend_common_1.Logger).debug('MessageEventBusDestination __type unknown');
+        }
+    }
+    return null;
+}

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination-sentry.ee.d.ts

@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/node';
+import type { MessageEventBusDestinationOptions, MessageEventBusDestinationSentryOptions } from 'n8n-workflow';
+import type { MessageEventBus, MessageWithCallback } from '../../../eventbus/message-event-bus/message-event-bus';
+import { MessageEventBusDestination } from './message-event-bus-destination.ee';
+export declare const isMessageEventBusDestinationSentryOptions: (candidate: unknown) => candidate is MessageEventBusDestinationSentryOptions;
+export declare class MessageEventBusDestinationSentry extends MessageEventBusDestination implements MessageEventBusDestinationSentryOptions {
+    dsn: string;
+    tracesSampleRate: number;
+    sendPayload: boolean;
+    sentryClient?: Sentry.NodeClient;
+    constructor(eventBusInstance: MessageEventBus, options: MessageEventBusDestinationSentryOptions);
+    receiveFromEventBus(emitterPayload: MessageWithCallback): Promise<boolean>;
+    serialize(): MessageEventBusDestinationSentryOptions;
+    static deserialize(eventBusInstance: MessageEventBus, data: MessageEventBusDestinationOptions): MessageEventBusDestinationSentry | null;
+    toString(): string;
+    close(): Promise<void>;
+}

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination-sentry.ee.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageEventBusDestinationSentry = exports.isMessageEventBusDestinationSentryOptions = void 0;
+const Sentry = __importStar(require("@sentry/node"));
+const constants_1 = require("../../../constants");
+const event_message_generic_1 = require("../../../eventbus/event-message-classes/event-message-generic");
+const message_event_bus_destination_ee_1 = require("./message-event-bus-destination.ee");
+const isMessageEventBusDestinationSentryOptions = (candidate) => {
+    const o = candidate;
+    if (!o)
+        return false;
+    return o.dsn !== undefined;
+};
+exports.isMessageEventBusDestinationSentryOptions = isMessageEventBusDestinationSentryOptions;
+class MessageEventBusDestinationSentry extends message_event_bus_destination_ee_1.MessageEventBusDestination {
+    constructor(eventBusInstance, options) {
+        super(eventBusInstance, options);
+        this.tracesSampleRate = 1.0;
+        this.label = options.label ?? 'Sentry DSN';
+        this.__type = options.__type ?? "$$MessageEventBusDestinationSentry";
+        this.dsn = options.dsn;
+        if (options.sendPayload)
+            this.sendPayload = options.sendPayload;
+        if (options.tracesSampleRate)
+            this.tracesSampleRate = options.tracesSampleRate;
+        const { ENVIRONMENT: environment } = process.env;
+        this.sentryClient = new Sentry.NodeClient({
+            dsn: this.dsn,
+            tracesSampleRate: this.tracesSampleRate,
+            environment,
+            release: constants_1.N8N_VERSION,
+            transport: Sentry.makeNodeTransport,
+            integrations: Sentry.getDefaultIntegrations({}),
+            stackParser: Sentry.defaultStackParser,
+        });
+    }
+    async receiveFromEventBus(emitterPayload) {
+        const { msg, confirmCallback } = emitterPayload;
+        let sendResult = false;
+        if (!this.sentryClient)
+            return sendResult;
+        if (msg.eventName !== event_message_generic_1.eventMessageGenericDestinationTestEvent) {
+            if (!this.license.isLogStreamingEnabled())
+                return sendResult;
+            if (!this.hasSubscribedToEvent(msg))
+                return sendResult;
+        }
+        try {
+            const payload = this.anonymizeAuditMessages ? msg.anonymize() : msg.payload;
+            const scope = new Sentry.Scope();
+            const level = (msg.eventName.toLowerCase().endsWith('error') ? 'error' : 'log');
+            scope.setLevel(level);
+            scope.setTags({
+                event: msg.getEventName(),
+                logger: this.label ?? this.getId(),
+                app: 'n8n',
+            });
+            if (this.sendPayload) {
+                scope.setExtras(payload);
+            }
+            const sentryResult = this.sentryClient.captureMessage(msg.message ?? msg.eventName, level, { event_id: msg.id, data: payload }, scope);
+            if (sentryResult) {
+                confirmCallback(msg, { id: this.id, name: this.label });
+                sendResult = true;
+            }
+        }
+        catch (error) {
+            this.logger.debug(`Failed to send message to Sentry destination: ${this.label}`, { error });
+            throw error;
+        }
+        return sendResult;
+    }
+    serialize() {
+        const abstractSerialized = super.serialize();
+        return {
+            ...abstractSerialized,
+            dsn: this.dsn,
+            tracesSampleRate: this.tracesSampleRate,
+            sendPayload: this.sendPayload,
+        };
+    }
+    static deserialize(eventBusInstance, data) {
+        if ('__type' in data &&
+            data.__type === "$$MessageEventBusDestinationSentry" &&
+            (0, exports.isMessageEventBusDestinationSentryOptions)(data)) {
+            return new MessageEventBusDestinationSentry(eventBusInstance, data);
+        }
+        return null;
+    }
+    toString() {
+        return JSON.stringify(this.serialize());
+    }
+    async close() {
+        await super.close();
+        await this.sentryClient?.close();
+    }
+}
+exports.MessageEventBusDestinationSentry = MessageEventBusDestinationSentry;

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination-syslog.ee.d.ts

@@ -0,0 +1,22 @@
+import type { SyslogClient } from '@n8n/syslog-client';
+import { Facility } from '@n8n/syslog-client';
+import type { MessageEventBusDestinationOptions, MessageEventBusDestinationSyslogOptions } from 'n8n-workflow';
+import type { MessageEventBus, MessageWithCallback } from '../../../eventbus/message-event-bus/message-event-bus';
+import { MessageEventBusDestination } from './message-event-bus-destination.ee';
+export declare const isMessageEventBusDestinationSyslogOptions: (candidate: unknown) => candidate is MessageEventBusDestinationSyslogOptions;
+export declare class MessageEventBusDestinationSyslog extends MessageEventBusDestination implements MessageEventBusDestinationSyslogOptions {
+    client: SyslogClient;
+    expectedStatusCode?: number;
+    host: string;
+    port: number;
+    protocol: 'udp' | 'tcp' | 'tls';
+    facility: Facility;
+    app_name: string;
+    eol: string;
+    constructor(eventBusInstance: MessageEventBus, options: MessageEventBusDestinationSyslogOptions);
+    receiveFromEventBus(emitterPayload: MessageWithCallback): Promise<boolean>;
+    serialize(): MessageEventBusDestinationSyslogOptions;
+    static deserialize(eventBusInstance: MessageEventBus, data: MessageEventBusDestinationOptions): MessageEventBusDestinationSyslog | null;
+    toString(): string;
+    close(): Promise<void>;
+}

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination-syslog.ee.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageEventBusDestinationSyslog = exports.isMessageEventBusDestinationSyslogOptions = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const di_1 = require("@n8n/di");
+const syslog_client_1 = require("@n8n/syslog-client");
+const event_message_generic_1 = require("../../../eventbus/event-message-classes/event-message-generic");
+const message_event_bus_destination_ee_1 = require("./message-event-bus-destination.ee");
+const isMessageEventBusDestinationSyslogOptions = (candidate) => {
+    const o = candidate;
+    if (!o)
+        return false;
+    return o.host !== undefined;
+};
+exports.isMessageEventBusDestinationSyslogOptions = isMessageEventBusDestinationSyslogOptions;
+class MessageEventBusDestinationSyslog extends message_event_bus_destination_ee_1.MessageEventBusDestination {
+    constructor(eventBusInstance, options) {
+        super(eventBusInstance, options);
+        this.__type = options.__type ?? "$$MessageEventBusDestinationSyslog";
+        this.label = options.label ?? 'Syslog Server';
+        this.host = options.host ?? 'localhost';
+        this.port = options.port ?? 514;
+        this.protocol = options.protocol ?? 'udp';
+        this.facility = options.facility ?? syslog_client_1.Facility.Local0;
+        this.app_name = options.app_name ?? 'n8n';
+        this.eol = options.eol ?? '\n';
+        this.expectedStatusCode = options.expectedStatusCode ?? 200;
+        if (this.protocol === 'tls' && !options.tlsCa) {
+            this.logger.error('Syslog - No TLS CA set - Unable to create the syslog client');
+        }
+        this.client = (0, syslog_client_1.createClient)(this.host, {
+            appName: this.app_name,
+            facility: syslog_client_1.Facility.Local0,
+            port: this.port,
+            rfc3164: false,
+            tlsCA: options.tlsCa,
+            transport: this.protocol === 'tcp'
+                ? syslog_client_1.Transport.Tcp
+                : this.protocol === 'tls'
+                    ? syslog_client_1.Transport.Tls
+                    : syslog_client_1.Transport.Udp,
+        });
+        this.logger.debug(`MessageEventBusDestinationSyslog with id ${this.getId()} initialized`);
+        this.client.on('error', function (error) {
+            di_1.Container.get(backend_common_1.Logger).error(`${error.message}`);
+        });
+    }
+    async receiveFromEventBus(emitterPayload) {
+        const { msg, confirmCallback } = emitterPayload;
+        let sendResult = false;
+        if (msg.eventName !== event_message_generic_1.eventMessageGenericDestinationTestEvent) {
+            if (!this.license.isLogStreamingEnabled())
+                return sendResult;
+            if (!this.hasSubscribedToEvent(msg))
+                return sendResult;
+        }
+        try {
+            const serializedMessage = msg.serialize();
+            if (this.anonymizeAuditMessages) {
+                serializedMessage.payload = msg.anonymize();
+            }
+            delete serializedMessage.__type;
+            await this.client.log(JSON.stringify(serializedMessage), {
+                severity: msg.eventName.toLowerCase().endsWith('error') ? syslog_client_1.Severity.Error : syslog_client_1.Severity.Debug,
+                msgid: msg.id,
+                timestamp: msg.ts.toJSDate(),
+            }, async (error) => {
+                if (error?.message) {
+                    this.logger.error(error.message);
+                }
+                else {
+                    confirmCallback(msg, { id: this.id, name: this.label });
+                    sendResult = true;
+                }
+            });
+        }
+        catch (error) {
+            if (error.message)
+                this.logger.error(error.message);
+            throw error;
+        }
+        if (msg.eventName === event_message_generic_1.eventMessageGenericDestinationTestEvent) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+        return sendResult;
+    }
+    serialize() {
+        const abstractSerialized = super.serialize();
+        return {
+            ...abstractSerialized,
+            expectedStatusCode: this.expectedStatusCode,
+            host: this.host,
+            port: this.port,
+            protocol: this.protocol,
+            facility: this.facility,
+            app_name: this.app_name,
+            eol: this.eol,
+        };
+    }
+    static deserialize(eventBusInstance, data) {
+        if ('__type' in data &&
+            data.__type === "$$MessageEventBusDestinationSyslog" &&
+            (0, exports.isMessageEventBusDestinationSyslogOptions)(data)) {
+            return new MessageEventBusDestinationSyslog(eventBusInstance, data);
+        }
+        return null;
+    }
+    toString() {
+        return JSON.stringify(this.serialize());
+    }
+    async close() {
+        await super.close();
+        this.client.close();
+    }
+}
+exports.MessageEventBusDestinationSyslog = MessageEventBusDestinationSyslog;

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination-webhook.ee.d.ts

@@ -0,0 +1,35 @@
+import type { AxiosInstance, AxiosRequestConfig } from 'axios';
+import type { MessageEventBusDestinationOptions, MessageEventBusDestinationWebhookParameterItem, MessageEventBusDestinationWebhookParameterOptions, MessageEventBusDestinationWebhookOptions } from 'n8n-workflow';
+import { CredentialsHelper } from '../../../credentials-helper';
+import type { MessageEventBus, MessageWithCallback } from '../../../eventbus/message-event-bus/message-event-bus';
+import { MessageEventBusDestination } from './message-event-bus-destination.ee';
+export declare const isMessageEventBusDestinationWebhookOptions: (candidate: unknown) => candidate is MessageEventBusDestinationWebhookOptions;
+export declare class MessageEventBusDestinationWebhook extends MessageEventBusDestination implements MessageEventBusDestinationWebhookOptions {
+    url: string;
+    responseCodeMustMatch: boolean;
+    expectedStatusCode: number;
+    method: string;
+    authentication: 'predefinedCredentialType' | 'genericCredentialType' | 'none';
+    sendQuery: boolean;
+    sendHeaders: boolean;
+    genericAuthType: string;
+    nodeCredentialType: string;
+    specifyHeaders: string;
+    specifyQuery: string;
+    jsonQuery: string;
+    jsonHeaders: string;
+    headerParameters: MessageEventBusDestinationWebhookParameterItem;
+    queryParameters: MessageEventBusDestinationWebhookParameterItem;
+    options: MessageEventBusDestinationWebhookParameterOptions;
+    sendPayload: boolean;
+    credentialsHelper?: CredentialsHelper;
+    axiosRequestOptions?: AxiosRequestConfig;
+    axiosInstance: AxiosInstance;
+    constructor(eventBusInstance: MessageEventBus, options: MessageEventBusDestinationWebhookOptions);
+    private buildAxiosSetting;
+    matchDecryptedCredentialType(credentialType: string): Promise<import("n8n-workflow").ICredentialDataDecryptedObject | null | undefined>;
+    generateAxiosOptions(): Promise<void>;
+    serialize(): MessageEventBusDestinationWebhookOptions;
+    static deserialize(eventBusInstance: MessageEventBus, data: MessageEventBusDestinationOptions): MessageEventBusDestinationWebhook | null;
+    receiveFromEventBus(emitterPayload: MessageWithCallback): Promise<boolean>;
+}

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination-webhook.ee.js

@@ -0,0 +1,328 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageEventBusDestinationWebhook = exports.isMessageEventBusDestinationWebhookOptions = void 0;
+const constants_1 = require("@n8n/constants");
+const di_1 = require("@n8n/di");
+const axios_1 = __importDefault(require("axios"));
+const http_1 = require("http");
+const https_1 = require("https");
+const n8n_core_1 = require("n8n-core");
+const n8n_workflow_1 = require("n8n-workflow");
+const credentials_helper_1 = require("../../../credentials-helper");
+const event_message_generic_1 = require("../../../eventbus/event-message-classes/event-message-generic");
+const message_event_bus_destination_ee_1 = require("./message-event-bus-destination.ee");
+const isMessageEventBusDestinationWebhookOptions = (candidate) => {
+    const o = candidate;
+    if (!o)
+        return false;
+    return o.url !== undefined;
+};
+exports.isMessageEventBusDestinationWebhookOptions = isMessageEventBusDestinationWebhookOptions;
+class MessageEventBusDestinationWebhook extends message_event_bus_destination_ee_1.MessageEventBusDestination {
+    constructor(eventBusInstance, options) {
+        super(eventBusInstance, options);
+        this.responseCodeMustMatch = false;
+        this.expectedStatusCode = 200;
+        this.method = 'POST';
+        this.authentication = 'none';
+        this.sendQuery = false;
+        this.sendHeaders = false;
+        this.genericAuthType = '';
+        this.nodeCredentialType = '';
+        this.specifyHeaders = '';
+        this.specifyQuery = '';
+        this.jsonQuery = '';
+        this.jsonHeaders = '';
+        this.headerParameters = { parameters: [] };
+        this.queryParameters = { parameters: [] };
+        this.options = {};
+        this.sendPayload = true;
+        this.url = options.url;
+        this.label = options.label ?? 'Webhook Endpoint';
+        this.__type = options.__type ?? "$$MessageEventBusDestinationWebhook";
+        if (options.responseCodeMustMatch)
+            this.responseCodeMustMatch = options.responseCodeMustMatch;
+        if (options.expectedStatusCode)
+            this.expectedStatusCode = options.expectedStatusCode;
+        if (options.method)
+            this.method = options.method;
+        if (options.authentication)
+            this.authentication = options.authentication;
+        if (options.sendQuery)
+            this.sendQuery = options.sendQuery;
+        if (options.sendHeaders)
+            this.sendHeaders = options.sendHeaders;
+        if (options.genericAuthType)
+            this.genericAuthType = options.genericAuthType;
+        if (options.nodeCredentialType)
+            this.nodeCredentialType = options.nodeCredentialType;
+        if (options.specifyHeaders)
+            this.specifyHeaders = options.specifyHeaders;
+        if (options.specifyQuery)
+            this.specifyQuery = options.specifyQuery;
+        if (options.jsonQuery)
+            this.jsonQuery = options.jsonQuery;
+        if (options.jsonHeaders)
+            this.jsonHeaders = options.jsonHeaders;
+        if (options.headerParameters)
+            this.headerParameters = options.headerParameters;
+        if (options.queryParameters)
+            this.queryParameters = options.queryParameters;
+        if (options.sendPayload)
+            this.sendPayload = options.sendPayload;
+        if (options.options)
+            this.options = options.options;
+        const axiosSetting = this.buildAxiosSetting(options);
+        this.axiosInstance = axios_1.default.create(axiosSetting);
+        this.logger.debug(`MessageEventBusDestinationWebhook with id ${this.getId()} initialized`);
+    }
+    buildAxiosSetting(axiosParameters) {
+        const axiosSetting = {
+            headers: {},
+            method: axiosParameters.method,
+            url: axiosParameters.url,
+            maxRedirects: 0,
+        };
+        if (axiosParameters.options?.redirect?.followRedirects) {
+            axiosSetting.maxRedirects = axiosParameters.options.redirect?.maxRedirects;
+        }
+        axiosSetting.proxy = axiosParameters.options?.proxy;
+        axiosSetting.timeout =
+            axiosParameters.options?.timeout ?? constants_1.LOGSTREAMING_DEFAULT_SOCKET_TIMEOUT_MS;
+        const agentOptions = {
+            keepAlive: axiosParameters.options?.socket?.keepAlive ?? true,
+            maxSockets: axiosParameters.options?.socket?.maxSockets ?? constants_1.LOGSTREAMING_DEFAULT_MAX_SOCKETS,
+            maxFreeSockets: axiosParameters.options?.socket?.maxFreeSockets ?? constants_1.LOGSTREAMING_DEFAULT_MAX_FREE_SOCKETS,
+            maxTotalSockets: axiosParameters.options?.socket?.maxSockets ?? constants_1.LOGSTREAMING_DEFAULT_MAX_TOTAL_SOCKETS,
+            timeout: axiosParameters.options?.timeout ?? constants_1.LOGSTREAMING_DEFAULT_SOCKET_TIMEOUT_MS,
+        };
+        const httpsAgentOptions = {
+            ...agentOptions,
+        };
+        if (axiosParameters.options?.allowUnauthorizedCerts) {
+            httpsAgentOptions.rejectUnauthorized = false;
+        }
+        const url = new URL(axiosParameters.url);
+        if (url.protocol === 'https:') {
+            axiosSetting.httpsAgent = new https_1.Agent(httpsAgentOptions);
+        }
+        else {
+            axiosSetting.httpAgent = new http_1.Agent(agentOptions);
+        }
+        return axiosSetting;
+    }
+    async matchDecryptedCredentialType(credentialType) {
+        const foundCredential = Object.entries(this.credentials).find((e) => e[0] === credentialType);
+        if (foundCredential) {
+            const credentialsDecrypted = await this.credentialsHelper?.getDecrypted({
+                externalSecretsProxy: di_1.Container.get(n8n_core_1.ExternalSecretsProxy),
+            }, foundCredential[1], foundCredential[0], 'internal', undefined, true);
+            return credentialsDecrypted;
+        }
+        return null;
+    }
+    async generateAxiosOptions() {
+        if (this.axiosRequestOptions) {
+            return;
+        }
+        this.axiosRequestOptions = {
+            headers: {},
+            method: this.method,
+            url: this.url,
+            maxRedirects: 0,
+        };
+        this.credentialsHelper ??= di_1.Container.get(credentials_helper_1.CredentialsHelper);
+        const sendQuery = this.sendQuery;
+        const specifyQuery = this.specifyQuery;
+        const sendHeaders = this.sendHeaders;
+        const specifyHeaders = this.specifyHeaders;
+        if (this.sendQuery && this.options.queryParameterArrays) {
+            Object.assign(this.axiosRequestOptions, {
+                qsStringifyOptions: { arrayFormat: this.options.queryParameterArrays },
+            });
+        }
+        const parametersToKeyValue = async (acc, cur) => {
+            const accumulator = await acc;
+            accumulator[cur.name] = cur.value;
+            return accumulator;
+        };
+        if (sendQuery && this.queryParameters.parameters) {
+            if (specifyQuery === 'keypair') {
+                this.axiosRequestOptions.params = this.queryParameters.parameters.reduce(parametersToKeyValue, Promise.resolve({}));
+            }
+            else if (specifyQuery === 'json') {
+                try {
+                    JSON.parse(this.jsonQuery);
+                }
+                catch {
+                    this.logger.error('JSON parameter needs to be valid JSON');
+                }
+                this.axiosRequestOptions.params = (0, n8n_workflow_1.jsonParse)(this.jsonQuery);
+            }
+        }
+        if (sendHeaders && this.headerParameters.parameters) {
+            if (specifyHeaders === 'keypair') {
+                this.axiosRequestOptions.headers = await this.headerParameters.parameters.reduce(parametersToKeyValue, Promise.resolve({}));
+            }
+            else if (specifyHeaders === 'json') {
+                try {
+                    JSON.parse(this.jsonHeaders);
+                }
+                catch {
+                    this.logger.error('JSON parameter needs to be valid JSON');
+                }
+                this.axiosRequestOptions.headers = (0, n8n_workflow_1.jsonParse)(this.jsonHeaders);
+            }
+        }
+        if (this.axiosRequestOptions.headers === undefined) {
+            this.axiosRequestOptions.headers = {};
+        }
+        this.axiosRequestOptions.headers['Content-Type'] = 'application/json';
+    }
+    serialize() {
+        const abstractSerialized = super.serialize();
+        return {
+            ...abstractSerialized,
+            url: this.url,
+            responseCodeMustMatch: this.responseCodeMustMatch,
+            expectedStatusCode: this.expectedStatusCode,
+            method: this.method,
+            authentication: this.authentication,
+            sendQuery: this.sendQuery,
+            sendHeaders: this.sendHeaders,
+            genericAuthType: this.genericAuthType,
+            nodeCredentialType: this.nodeCredentialType,
+            specifyHeaders: this.specifyHeaders,
+            specifyQuery: this.specifyQuery,
+            jsonQuery: this.jsonQuery,
+            jsonHeaders: this.jsonHeaders,
+            headerParameters: this.headerParameters,
+            queryParameters: this.queryParameters,
+            sendPayload: this.sendPayload,
+            options: this.options,
+            credentials: this.credentials,
+        };
+    }
+    static deserialize(eventBusInstance, data) {
+        if ('__type' in data &&
+            data.__type === "$$MessageEventBusDestinationWebhook" &&
+            (0, exports.isMessageEventBusDestinationWebhookOptions)(data)) {
+            return new MessageEventBusDestinationWebhook(eventBusInstance, data);
+        }
+        return null;
+    }
+    async receiveFromEventBus(emitterPayload) {
+        const { msg, confirmCallback } = emitterPayload;
+        let sendResult = false;
+        if (msg.eventName !== event_message_generic_1.eventMessageGenericDestinationTestEvent) {
+            if (!this.license.isLogStreamingEnabled())
+                return sendResult;
+            if (!this.hasSubscribedToEvent(msg))
+                return sendResult;
+        }
+        await this.generateAxiosOptions();
+        const request = {
+            ...(this.axiosRequestOptions ?? {}),
+        };
+        const payload = this.anonymizeAuditMessages ? msg.anonymize() : msg.payload;
+        if (['PATCH', 'POST', 'PUT', 'GET'].includes(this.method.toUpperCase())) {
+            if (this.sendPayload) {
+                request.data = {
+                    ...msg,
+                    __type: undefined,
+                    payload,
+                    ts: msg.ts.toISO(),
+                };
+            }
+            else {
+                request.data = {
+                    ...msg,
+                    __type: undefined,
+                    payload: undefined,
+                    ts: msg.ts.toISO(),
+                };
+            }
+        }
+        let httpBasicAuth;
+        let httpDigestAuth;
+        let httpHeaderAuth;
+        let httpQueryAuth;
+        if (this.authentication === 'genericCredentialType') {
+            if (this.genericAuthType === 'httpBasicAuth') {
+                try {
+                    httpBasicAuth = await this.matchDecryptedCredentialType('httpBasicAuth');
+                }
+                catch { }
+            }
+            else if (this.genericAuthType === 'httpDigestAuth') {
+                try {
+                    httpDigestAuth = await this.matchDecryptedCredentialType('httpDigestAuth');
+                }
+                catch { }
+            }
+            else if (this.genericAuthType === 'httpHeaderAuth') {
+                try {
+                    httpHeaderAuth = await this.matchDecryptedCredentialType('httpHeaderAuth');
+                }
+                catch { }
+            }
+            else if (this.genericAuthType === 'httpQueryAuth') {
+                try {
+                    httpQueryAuth = await this.matchDecryptedCredentialType('httpQueryAuth');
+                }
+                catch { }
+            }
+        }
+        if (httpBasicAuth) {
+            request.auth = {
+                username: httpBasicAuth.user,
+                password: httpBasicAuth.password,
+            };
+        }
+        else if (httpHeaderAuth) {
+            request.headers = {
+                ...request.headers,
+                [httpHeaderAuth.name]: httpHeaderAuth.value,
+            };
+        }
+        else if (httpQueryAuth) {
+            request.params = {
+                ...request.params,
+                [httpQueryAuth.name]: httpQueryAuth.value,
+            };
+        }
+        else if (httpDigestAuth) {
+            request.auth = {
+                username: httpDigestAuth.user,
+                password: httpDigestAuth.password,
+            };
+        }
+        try {
+            const requestResponse = await this.axiosInstance.request(request);
+            if (requestResponse) {
+                if (this.responseCodeMustMatch) {
+                    if (requestResponse.status === this.expectedStatusCode) {
+                        confirmCallback(msg, { id: this.id, name: this.label });
+                        sendResult = true;
+                    }
+                    else {
+                        sendResult = false;
+                    }
+                }
+                else {
+                    confirmCallback(msg, { id: this.id, name: this.label });
+                    sendResult = true;
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Webhook destination ${this.label} (${this.id}) failed to send message to: ${this.url} - ${error.message}`);
+            throw error;
+        }
+        return sendResult;
+    }
+}
+exports.MessageEventBusDestinationWebhook = MessageEventBusDestinationWebhook;