n8n-nodes-base 0.234.0 → 1.0.1

package/dist/nodes/Webhook/Webhook.node.js

@@ -12,13 +12,25 @@ const basic_auth_1 = __importDefault(require("basic-auth"));
 const formidable_1 = __importDefault(require("formidable"));
 const isbot_1 = __importDefault(require("isbot"));
 const tmp_promise_1 = require("tmp-promise");
-const description_1 = require("./description");
-const error_1 = require("./error");
 const pipeline = (0, util_1.promisify)(stream_1.default.pipeline);
-class Webhook extends n8n_workflow_1.Node {
+function authorizationError(resp, realm, responseCode, message) {
+    if (message === undefined) {
+        message = 'Authorization problem!';
+        if (responseCode === 401) {
+            message = 'Authorization is required!';
+        }
+        else if (responseCode === 403) {
+            message = 'Authorization data is wrong!';
+        }
+    }
+    resp.writeHead(responseCode, { 'WWW-Authenticate': `Basic realm="${realm}"` });
+    resp.end(message);
+    return {
+        noWebhookResponse: true,
+    };
+}
+class Webhook {
     constructor() {
-        super(...arguments);
-        this.authPropertyName = 'authentication';
         this.description = {
             displayName: 'Webhook',
             icon: 'file:webhook.svg',
@@ -41,11 +53,96 @@ class Webhook extends n8n_workflow_1.Node {
             },
             inputs: [],
             outputs: ['main'],
-            credentials: (0, description_1.credentialsProperty)(this.authPropertyName),
-            webhooks: [description_1.defaultWebhookDescription],
+            credentials: [
+                {
+                    name: 'httpBasicAuth',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ['basicAuth'],
+                        },
+                    },
+                },
+                {
+                    name: 'httpHeaderAuth',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ['headerAuth'],
+                        },
+                    },
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: '={{$parameter["httpMethod"]}}',
+                    isFullPath: true,
+                    responseCode: '={{$parameter["responseCode"]}}',
+                    responseMode: '={{$parameter["responseMode"]}}',
+                    responseData: '={{$parameter["responseData"] || ($parameter.options.noResponseBody ? "noData" : undefined) }}',
+                    responseBinaryPropertyName: '={{$parameter["responseBinaryPropertyName"]}}',
+                    responseContentType: '={{$parameter["options"]["responseContentType"]}}',
+                    responsePropertyName: '={{$parameter["options"]["responsePropertyName"]}}',
+                    responseHeaders: '={{$parameter["options"]["responseHeaders"]}}',
+                    path: '={{$parameter["path"]}}',
+                },
+            ],
             properties: [
-                (0, description_1.authenticationProperty)(this.authPropertyName),
-                description_1.httpMethodsProperty,
+                {
+                    displayName: 'Authentication',
+                    name: 'authentication',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Basic Auth',
+                            value: 'basicAuth',
+                        },
+                        {
+                            name: 'Header Auth',
+                            value: 'headerAuth',
+                        },
+                        {
+                            name: 'None',
+                            value: 'none',
+                        },
+                    ],
+                    default: 'none',
+                    description: 'The way to authenticate',
+                },
+                {
+                    displayName: 'HTTP Method',
+                    name: 'httpMethod',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'DELETE',
+                            value: 'DELETE',
+                        },
+                        {
+                            name: 'GET',
+                            value: 'GET',
+                        },
+                        {
+                            name: 'HEAD',
+                            value: 'HEAD',
+                        },
+                        {
+                            name: 'PATCH',
+                            value: 'PATCH',
+                        },
+                        {
+                            name: 'POST',
+                            value: 'POST',
+                        },
+                        {
+                            name: 'PUT',
+                            value: 'PUT',
+                        },
+                    ],
+                    default: 'GET',
+                    description: 'The HTTP method to listen to',
+                },
                 {
                     displayName: 'Path',
                     name: 'path',
@@ -55,7 +152,30 @@ class Webhook extends n8n_workflow_1.Node {
                     required: true,
                     description: 'The path to listen to',
                 },
-                description_1.responseModeProperty,
+                {
+                    displayName: 'Respond',
+                    name: 'responseMode',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Immediately',
+                            value: 'onReceived',
+                            description: 'As soon as this node executes',
+                        },
+                        {
+                            name: 'When Last Node Finishes',
+                            value: 'lastNode',
+                            description: 'Returns data of the last-executed node',
+                        },
+                        {
+                            name: "Using 'Respond to Webhook' Node",
+                            value: 'responseNode',
+                            description: 'Response defined in that node',
+                        },
+                    ],
+                    default: 'onReceived',
+                    description: 'When and how to respond to the webhook',
+                },
                 {
                     displayName: 'Insert a \'Respond to Webhook\' node to control when and how you respond. <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.respondtowebhook/" target="_blank">More details</a>',
                     name: 'webhookNotice',
@@ -67,171 +187,363 @@ class Webhook extends n8n_workflow_1.Node {
                     },
                     default: '',
                 },
-                description_1.responseCodeProperty,
-                description_1.responseDataProperty,
-                description_1.responseBinaryPropertyNameProperty,
-                description_1.optionsProperty,
+                {
+                    displayName: 'Response Code',
+                    name: 'responseCode',
+                    type: 'number',
+                    displayOptions: {
+                        hide: {
+                            responseMode: ['responseNode'],
+                        },
+                    },
+                    typeOptions: {
+                        minValue: 100,
+                        maxValue: 599,
+                    },
+                    default: 200,
+                    description: 'The HTTP Response code to return',
+                },
+                {
+                    displayName: 'Response Data',
+                    name: 'responseData',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            responseMode: ['lastNode'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'All Entries',
+                            value: 'allEntries',
+                            description: 'Returns all the entries of the last node. Always returns an array.',
+                        },
+                        {
+                            name: 'First Entry JSON',
+                            value: 'firstEntryJson',
+                            description: 'Returns the JSON data of the first entry of the last node. Always returns a JSON object.',
+                        },
+                        {
+                            name: 'First Entry Binary',
+                            value: 'firstEntryBinary',
+                            description: 'Returns the binary data of the first entry of the last node. Always returns a binary file.',
+                        },
+                        {
+                            name: 'No Response Body',
+                            value: 'noData',
+                            description: 'Returns without a body',
+                        },
+                    ],
+                    default: 'firstEntryJson',
+                    description: 'What data should be returned. If it should return all items as an array or only the first item as object.',
+                },
+                {
+                    displayName: 'Property Name',
+                    name: 'responseBinaryPropertyName',
+                    type: 'string',
+                    required: true,
+                    default: 'data',
+                    displayOptions: {
+                        show: {
+                            responseData: ['firstEntryBinary'],
+                        },
+                    },
+                    description: 'Name of the binary property to return',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Binary Data',
+                            name: 'binaryData',
+                            type: 'boolean',
+                            displayOptions: {
+                                show: {
+                                    '/httpMethod': ['PATCH', 'PUT', 'POST'],
+                                },
+                            },
+                            default: false,
+                            description: 'Whether the webhook will receive binary data',
+                        },
+                        {
+                            displayName: 'Binary Property',
+                            name: 'binaryPropertyName',
+                            type: 'string',
+                            default: 'data',
+                            required: true,
+                            displayOptions: {
+                                show: {
+                                    binaryData: [true],
+                                },
+                            },
+                            description: 'Name of the binary property to write the data of the received file to. If the data gets received via "Form-Data Multipart" it will be the prefix and a number starting with 0 will be attached to it.',
+                        },
+                        {
+                            displayName: 'Ignore Bots',
+                            name: 'ignoreBots',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to ignore requests from bots like link previewers and web crawlers',
+                        },
+                        {
+                            displayName: 'No Response Body',
+                            name: 'noResponseBody',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to send any body in the response',
+                            displayOptions: {
+                                hide: {
+                                    rawBody: [true],
+                                },
+                                show: {
+                                    '/responseMode': ['onReceived'],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Raw Body',
+                            name: 'rawBody',
+                            type: 'boolean',
+                            displayOptions: {
+                                hide: {
+                                    binaryData: [true],
+                                    noResponseBody: [true],
+                                },
+                            },
+                            default: false,
+                            description: 'Raw body (binary)',
+                        },
+                        {
+                            displayName: 'Response Data',
+                            name: 'responseData',
+                            type: 'string',
+                            displayOptions: {
+                                show: {
+                                    '/responseMode': ['onReceived'],
+                                },
+                                hide: {
+                                    noResponseBody: [true],
+                                },
+                            },
+                            default: '',
+                            placeholder: 'success',
+                            description: 'Custom response data to send',
+                        },
+                        {
+                            displayName: 'Response Content-Type',
+                            name: 'responseContentType',
+                            type: 'string',
+                            displayOptions: {
+                                show: {
+                                    '/responseData': ['firstEntryJson'],
+                                    '/responseMode': ['lastNode'],
+                                },
+                            },
+                            default: '',
+                            placeholder: 'application/xml',
+                            description: 'Set a custom content-type to return if another one as the "application/json" should be returned',
+                        },
+                        {
+                            displayName: 'Response Headers',
+                            name: 'responseHeaders',
+                            placeholder: 'Add Response Header',
+                            description: 'Add headers to the webhook response',
+                            type: 'fixedCollection',
+                            typeOptions: {
+                                multipleValues: true,
+                            },
+                            default: {},
+                            options: [
+                                {
+                                    name: 'entries',
+                                    displayName: 'Entries',
+                                    values: [
+                                        {
+                                            displayName: 'Name',
+                                            name: 'name',
+                                            type: 'string',
+                                            default: '',
+                                            description: 'Name of the header',
+                                        },
+                                        {
+                                            displayName: 'Value',
+                                            name: 'value',
+                                            type: 'string',
+                                            default: '',
+                                            description: 'Value of the header',
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            displayName: 'Property Name',
+                            name: 'responsePropertyName',
+                            type: 'string',
+                            displayOptions: {
+                                show: {
+                                    '/responseData': ['firstEntryJson'],
+                                    '/responseMode': ['lastNode'],
+                                },
+                            },
+                            default: 'data',
+                            description: 'Name of the property to return the data of instead of the whole JSON',
+                        },
+                    ],
+                },
             ],
         };
     }
-    async webhook(context) {
+    async webhook() {
         var _a;
-        const options = context.getNodeParameter('options', {});
-        const req = context.getRequestObject();
-        const resp = context.getResponseObject();
-        try {
-            if (options.ignoreBots && (0, isbot_1.default)(req.headers['user-agent']))
-                throw new error_1.WebhookAuthorizationError(403);
-            await this.validateAuth(context);
-        }
-        catch (error) {
-            if (error instanceof error_1.WebhookAuthorizationError) {
-                resp.writeHead(error.responseCode, { 'WWW-Authenticate': 'Basic realm="Webhook"' });
-                resp.end(error.message);
-                return { noWebhookResponse: true };
-            }
-            throw error;
+        const authentication = this.getNodeParameter('authentication');
+        const options = this.getNodeParameter('options', {});
+        const req = this.getRequestObject();
+        const resp = this.getResponseObject();
+        const headers = this.getHeaderData();
+        const realm = 'Webhook';
+        const ignoreBots = options.ignoreBots;
+        if (ignoreBots && (0, isbot_1.default)(headers['user-agent'])) {
+            return authorizationError(resp, realm, 403);
         }
-        const mimeType = (_a = req.headers['content-type']) !== null && _a !== void 0 ? _a : 'application/json';
-        if (mimeType.includes('multipart/form-data')) {
-            return this.handleFormData(context);
-        }
-        if (options.binaryData) {
-            return this.handleBinaryData(context);
-        }
-        const response = {
-            json: {
-                headers: req.headers,
-                params: req.params,
-                query: req.query,
-                body: req.body,
-            },
-            binary: options.rawBody
-                ? {
-                    data: {
-                        data: req.rawBody.toString(n8n_workflow_1.BINARY_ENCODING),
-                        mimeType,
-                    },
-                }
-                : undefined,
-        };
-        return {
-            webhookResponse: options.responseData,
-            workflowData: [[response]],
-        };
-    }
-    async validateAuth(context) {
-        const authentication = context.getNodeParameter(this.authPropertyName);
-        if (authentication === 'none')
-            return;
-        const req = context.getRequestObject();
-        const headers = context.getHeaderData();
         if (authentication === 'basicAuth') {
-            let expectedAuth;
+            let httpBasicAuth;
             try {
-                expectedAuth = await context.getCredentials('httpBasicAuth');
+                httpBasicAuth = await this.getCredentials('httpBasicAuth');
+            }
+            catch (error) {
             }
-            catch { }
-            if (expectedAuth === undefined || !expectedAuth.user || !expectedAuth.password) {
-                throw new error_1.WebhookAuthorizationError(500, 'No authentication data defined on node!');
+            if (httpBasicAuth === undefined || !httpBasicAuth.user || !httpBasicAuth.password) {
+                return authorizationError(resp, realm, 500, 'No authentication data defined on node!');
             }
-            const providedAuth = (0, basic_auth_1.default)(req);
-            if (!providedAuth)
-                throw new error_1.WebhookAuthorizationError(401);
-            if (providedAuth.name !== expectedAuth.user || providedAuth.pass !== expectedAuth.password) {
-                throw new error_1.WebhookAuthorizationError(403);
+            const basicAuthData = (0, basic_auth_1.default)(req);
+            if (basicAuthData === undefined) {
+                return authorizationError(resp, realm, 401);
+            }
+            if (basicAuthData.name !== httpBasicAuth.user ||
+                basicAuthData.pass !== httpBasicAuth.password) {
+                return authorizationError(resp, realm, 403);
             }
         }
         else if (authentication === 'headerAuth') {
-            let expectedAuth;
+            let httpHeaderAuth;
             try {
-                expectedAuth = await context.getCredentials('httpHeaderAuth');
+                httpHeaderAuth = await this.getCredentials('httpHeaderAuth');
+            }
+            catch (error) {
             }
-            catch { }
-            if (expectedAuth === undefined || !expectedAuth.name || !expectedAuth.value) {
-                throw new error_1.WebhookAuthorizationError(500, 'No authentication data defined on node!');
+            if (httpHeaderAuth === undefined || !httpHeaderAuth.name || !httpHeaderAuth.value) {
+                return authorizationError(resp, realm, 500, 'No authentication data defined on node!');
             }
-            const headerName = expectedAuth.name.toLowerCase();
-            const expectedValue = expectedAuth.value;
+            const headerName = httpHeaderAuth.name.toLowerCase();
+            const headerValue = httpHeaderAuth.value;
             if (!headers.hasOwnProperty(headerName) ||
-                headers[headerName] !== expectedValue) {
-                throw new error_1.WebhookAuthorizationError(403);
+                headers[headerName] !== headerValue) {
+                return authorizationError(resp, realm, 403);
             }
         }
-    }
-    async handleFormData(context) {
-        const req = context.getRequestObject();
-        const options = context.getNodeParameter('options', {});
-        const form = new formidable_1.default.IncomingForm({ multiples: true });
-        return new Promise((resolve, _reject) => {
-            form.parse(req, async (err, data, files) => {
-                const returnItem = {
-                    binary: {},
-                    json: {
-                        headers: req.headers,
-                        params: req.params,
-                        query: req.query,
-                        body: data,
-                    },
-                };
-                let count = 0;
-                for (const xfile of Object.keys(files)) {
-                    const processFiles = [];
-                    let multiFile = false;
-                    if (Array.isArray(files[xfile])) {
-                        processFiles.push(...files[xfile]);
-                        multiFile = true;
-                    }
-                    else {
-                        processFiles.push(files[xfile]);
-                    }
-                    let fileCount = 0;
-                    for (const file of processFiles) {
-                        let binaryPropertyName = xfile;
-                        if (binaryPropertyName.endsWith('[]')) {
-                            binaryPropertyName = binaryPropertyName.slice(0, -2);
+        const mimeType = (_a = headers['content-type']) !== null && _a !== void 0 ? _a : 'application/json';
+        if (mimeType.includes('multipart/form-data')) {
+            const form = new formidable_1.default.IncomingForm({ multiples: true });
+            return new Promise((resolve, _reject) => {
+                form.parse(req, async (err, data, files) => {
+                    const returnItem = {
+                        binary: {},
+                        json: {
+                            headers,
+                            params: this.getParamsData(),
+                            query: this.getQueryData(),
+                            body: data,
+                        },
+                    };
+                    let count = 0;
+                    for (const xfile of Object.keys(files)) {
+                        const processFiles = [];
+                        let multiFile = false;
+                        if (Array.isArray(files[xfile])) {
+                            processFiles.push(...files[xfile]);
+                            multiFile = true;
                         }
-                        if (multiFile) {
-                            binaryPropertyName += fileCount++;
+                        else {
+                            processFiles.push(files[xfile]);
                         }
-                        if (options.binaryPropertyName) {
-                            binaryPropertyName = `${options.binaryPropertyName}${count}`;
+                        let fileCount = 0;
+                        for (const file of processFiles) {
+                            let binaryPropertyName = xfile;
+                            if (binaryPropertyName.endsWith('[]')) {
+                                binaryPropertyName = binaryPropertyName.slice(0, -2);
+                            }
+                            if (multiFile) {
+                                binaryPropertyName += fileCount++;
+                            }
+                            if (options.binaryPropertyName) {
+                                binaryPropertyName = `${options.binaryPropertyName}${count}`;
+                            }
+                            const fileJson = file.toJSON();
+                            returnItem.binary[binaryPropertyName] = await this.nodeHelpers.copyBinaryFile(file.path, fileJson.name || fileJson.filename, fileJson.type);
+                            count += 1;
                         }
-                        const fileJson = file.toJSON();
-                        returnItem.binary[binaryPropertyName] = await context.nodeHelpers.copyBinaryFile(file.path, fileJson.name || fileJson.filename, fileJson.type);
-                        count += 1;
                     }
-                }
-                resolve({ workflowData: [[returnItem]] });
+                    resolve({
+                        workflowData: [[returnItem]],
+                    });
+                });
             });
-        });
-    }
-    async handleBinaryData(context) {
-        var _a;
-        const req = context.getRequestObject();
-        const options = context.getNodeParameter('options', {});
-        const binaryFile = await (0, tmp_promise_1.file)({ prefix: 'n8n-webhook-' });
-        try {
-            await pipeline(req, fs_1.default.createWriteStream(binaryFile.path));
-            const returnItem = {
-                binary: {},
-                json: {
-                    headers: req.headers,
-                    params: req.params,
-                    query: req.query,
-                    body: req.body,
+        }
+        if (options.binaryData === true) {
+            const binaryFile = await (0, tmp_promise_1.file)({ prefix: 'n8n-webhook-' });
+            try {
+                await pipeline(req, fs_1.default.createWriteStream(binaryFile.path));
+                const returnItem = {
+                    binary: {},
+                    json: {
+                        headers,
+                        params: this.getParamsData(),
+                        query: this.getQueryData(),
+                        body: this.getBodyData(),
+                    },
+                };
+                const binaryPropertyName = (options.binaryPropertyName || 'data');
+                returnItem.binary[binaryPropertyName] = await this.nodeHelpers.copyBinaryFile(binaryFile.path, mimeType);
+                return {
+                    workflowData: [[returnItem]],
+                };
+            }
+            catch (error) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error);
+            }
+            finally {
+                await binaryFile.cleanup();
+            }
+        }
+        const response = {
+            json: {
+                headers,
+                params: this.getParamsData(),
+                query: this.getQueryData(),
+                body: this.getBodyData(),
+            },
+        };
+        if (options.rawBody) {
+            response.binary = {
+                data: {
+                    data: req.rawBody.toString(n8n_workflow_1.BINARY_ENCODING),
+                    mimeType,
                 },
             };
-            const binaryPropertyName = (options.binaryPropertyName || 'data');
-            returnItem.binary[binaryPropertyName] = await context.nodeHelpers.copyBinaryFile(binaryFile.path, (_a = req.headers['content-type']) !== null && _a !== void 0 ? _a : 'application/octet-stream');
-            return { workflowData: [[returnItem]] };
-        }
-        catch (error) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), error);
         }
-        finally {
-            await binaryFile.cleanup();
+        let webhookResponse;
+        if (options.responseData) {
+            webhookResponse = options.responseData;
         }
+        return {
+            webhookResponse,
+            workflowData: [[response]],
+        };
     }
 }
 exports.Webhook = Webhook;