n8n-nodes-base 1.0.5 → 1.1.0

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

@@ -12,25 +12,13 @@ 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);
-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 {
+class Webhook extends n8n_workflow_1.Node {
     constructor() {
+        super(...arguments);
+        this.authPropertyName = 'authentication';
         this.description = {
             displayName: 'Webhook',
             icon: 'file:webhook.svg',
@@ -53,96 +41,11 @@ class Webhook {
             },
             inputs: [],
             outputs: ['main'],
-            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"]}}',
-                },
-            ],
+            credentials: (0, description_1.credentialsProperty)(this.authPropertyName),
+            webhooks: [description_1.defaultWebhookDescription],
             properties: [
-                {
-                    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',
-                },
+                (0, description_1.authenticationProperty)(this.authPropertyName),
+                description_1.httpMethodsProperty,
                 {
                     displayName: 'Path',
                     name: 'path',
@@ -152,30 +55,7 @@ class Webhook {
                     required: true,
                     description: 'The path to listen to',
                 },
-                {
-                    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',
-                },
+                description_1.responseModeProperty,
                 {
                     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',
@@ -187,363 +67,171 @@ class Webhook {
                     },
                     default: '',
                 },
-                {
-                    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',
-                        },
-                    ],
-                },
+                description_1.responseCodeProperty,
+                description_1.responseDataProperty,
+                description_1.responseBinaryPropertyNameProperty,
+                description_1.optionsProperty,
             ],
         };
     }
-    async webhook() {
+    async webhook(context) {
         var _a;
-        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 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 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 httpBasicAuth;
+            let expectedAuth;
             try {
-                httpBasicAuth = await this.getCredentials('httpBasicAuth');
-            }
-            catch (error) {
+                expectedAuth = await context.getCredentials('httpBasicAuth');
             }
-            if (httpBasicAuth === undefined || !httpBasicAuth.user || !httpBasicAuth.password) {
-                return authorizationError(resp, realm, 500, 'No authentication data defined on node!');
+            catch { }
+            if (expectedAuth === undefined || !expectedAuth.user || !expectedAuth.password) {
+                throw new error_1.WebhookAuthorizationError(500, 'No authentication data defined on node!');
             }
-            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);
+            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);
             }
         }
         else if (authentication === 'headerAuth') {
-            let httpHeaderAuth;
+            let expectedAuth;
             try {
-                httpHeaderAuth = await this.getCredentials('httpHeaderAuth');
-            }
-            catch (error) {
+                expectedAuth = await context.getCredentials('httpHeaderAuth');
             }
-            if (httpHeaderAuth === undefined || !httpHeaderAuth.name || !httpHeaderAuth.value) {
-                return authorizationError(resp, realm, 500, 'No authentication data defined on node!');
+            catch { }
+            if (expectedAuth === undefined || !expectedAuth.name || !expectedAuth.value) {
+                throw new error_1.WebhookAuthorizationError(500, 'No authentication data defined on node!');
             }
-            const headerName = httpHeaderAuth.name.toLowerCase();
-            const headerValue = httpHeaderAuth.value;
+            const headerName = expectedAuth.name.toLowerCase();
+            const expectedValue = expectedAuth.value;
             if (!headers.hasOwnProperty(headerName) ||
-                headers[headerName] !== headerValue) {
-                return authorizationError(resp, realm, 403);
+                headers[headerName] !== expectedValue) {
+                throw new error_1.WebhookAuthorizationError(403);
             }
         }
-        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;
-                        }
-                        else {
-                            processFiles.push(files[xfile]);
-                        }
-                        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;
-                        }
-                    }
-                    resolve({
-                        workflowData: [[returnItem]],
-                    });
-                });
-            });
-        }
-        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));
+    }
+    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,
-                        params: this.getParamsData(),
-                        query: this.getQueryData(),
-                        body: this.getBodyData(),
+                        headers: req.headers,
+                        params: req.params,
+                        query: req.query,
+                        body: data,
                     },
                 };
-                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,
+                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);
+                        }
+                        if (multiFile) {
+                            binaryPropertyName += fileCount++;
+                        }
+                        if (options.binaryPropertyName) {
+                            binaryPropertyName = `${options.binaryPropertyName}${count}`;
+                        }
+                        const fileJson = file.toJSON();
+                        returnItem.binary[binaryPropertyName] = await context.nodeHelpers.copyBinaryFile(file.path, fileJson.name || fileJson.filename, fileJson.type);
+                        count += 1;
+                    }
+                }
+                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,
                 },
             };
+            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]] };
         }
-        let webhookResponse;
-        if (options.responseData) {
-            webhookResponse = options.responseData;
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), error);
+        }
+        finally {
+            await binaryFile.cleanup();
         }
-        return {
-            webhookResponse,
-            workflowData: [[response]],
-        };
     }
 }
 exports.Webhook = Webhook;