n8n-nodes-base 0.234.0 → 1.0.1

package/dist/nodes/Wait/Wait.node.js

@@ -1,19 +1,36 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Wait = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const description_1 = require("../Webhook/description");
-const Webhook_node_1 = require("../Webhook/Webhook.node");
-const displayOnWebhook = {
-    show: {
-        resume: ['webhook'],
-    },
-};
-class Wait extends Webhook_node_1.Webhook {
+const fs_1 = __importDefault(require("fs"));
+const stream_1 = __importDefault(require("stream"));
+const util_1 = require("util");
+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 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 Wait {
     constructor() {
-        var _a, _b;
-        super(...arguments);
-        this.authPropertyName = 'incomingAuthentication';
         this.description = {
             displayName: 'Wait',
             name: 'wait',
@@ -27,16 +44,69 @@ class Wait extends Webhook_node_1.Webhook {
             },
             inputs: ['main'],
             outputs: ['main'],
-            credentials: (0, description_1.credentialsProperty)(this.authPropertyName),
+            credentials: [
+                {
+                    name: 'httpBasicAuth',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            incomingAuthentication: ['basicAuth'],
+                        },
+                    },
+                },
+                {
+                    name: 'httpHeaderAuth',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            incomingAuthentication: ['headerAuth'],
+                        },
+                    },
+                },
+            ],
             webhooks: [
                 {
-                    ...description_1.defaultWebhookDescription,
+                    name: 'default',
+                    httpMethod: '={{$parameter["httpMethod"]}}',
+                    isFullPath: true,
+                    responseCode: '={{$parameter["responseCode"]}}',
+                    responseMode: '={{$parameter["responseMode"]}}',
                     responseData: '={{$parameter["responseData"]}}',
+                    responseBinaryPropertyName: '={{$parameter["responseBinaryPropertyName"]}}',
+                    responseContentType: '={{$parameter["options"]["responseContentType"]}}',
+                    responsePropertyName: '={{$parameter["options"]["responsePropertyName"]}}',
+                    responseHeaders: '={{$parameter["options"]["responseHeaders"]}}',
                     path: '={{$parameter["options"]["webhookSuffix"] || ""}}',
                     restartWebhook: true,
                 },
             ],
             properties: [
+                {
+                    displayName: 'Webhook Authentication',
+                    name: 'incomingAuthentication',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            resume: ['webhook'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Basic Auth',
+                            value: 'basicAuth',
+                        },
+                        {
+                            name: 'Header Auth',
+                            value: 'headerAuth',
+                        },
+                        {
+                            name: 'None',
+                            value: 'none',
+                        },
+                    ],
+                    default: 'none',
+                    description: 'If and how incoming resume-webhook-requests to $execution.resumeUrl should be authenticated for additional security',
+                },
                 {
                     displayName: 'Resume',
                     name: 'resume',
@@ -61,11 +131,6 @@ class Wait extends Webhook_node_1.Webhook {
                     default: 'timeInterval',
                     description: 'Determines the waiting mode to use before the workflow continues',
                 },
-                {
-                    ...(0, description_1.authenticationProperty)(this.authPropertyName),
-                    description: 'If and how incoming resume-webhook-requests to $execution.resumeUrl should be authenticated for additional security',
-                    displayOptions: displayOnWebhook,
-                },
                 {
                     displayName: 'Date and Time',
                     name: 'dateTime',
@@ -128,39 +193,139 @@ class Wait extends Webhook_node_1.Webhook {
                     displayName: 'The webhook URL will be generated at run time. It can be referenced with the <strong>$execution.resumeUrl</strong> variable. Send it somewhere before getting to this node. <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/?utm_source=n8n_app&utm_medium=node_settings_modal-credential_link&utm_campaign=n8n-nodes-base.wait" target="_blank">More info</a>',
                     name: 'webhookNotice',
                     type: 'notice',
-                    displayOptions: displayOnWebhook,
+                    displayOptions: {
+                        show: {
+                            resume: ['webhook'],
+                        },
+                    },
                     default: '',
                 },
                 {
-                    ...description_1.httpMethodsProperty,
-                    displayOptions: displayOnWebhook,
+                    displayName: 'HTTP Method',
+                    name: 'httpMethod',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            resume: ['webhook'],
+                        },
+                    },
+                    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 of the Webhook call',
                 },
                 {
-                    ...description_1.responseCodeProperty,
-                    displayOptions: displayOnWebhook,
+                    displayName: 'Response Code',
+                    name: 'responseCode',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            resume: ['webhook'],
+                        },
+                    },
+                    typeOptions: {
+                        minValue: 100,
+                        maxValue: 599,
+                    },
+                    default: 200,
+                    description: 'The HTTP Response code to return',
                 },
                 {
-                    ...description_1.responseModeProperty,
-                    displayOptions: displayOnWebhook,
+                    displayName: 'Respond',
+                    name: 'responseMode',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            resume: ['webhook'],
+                        },
+                    },
+                    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.responseDataProperty,
+                    displayName: 'Response Data',
+                    name: 'responseData',
+                    type: 'options',
                     displayOptions: {
                         show: {
-                            ...(_a = description_1.responseDataProperty.displayOptions) === null || _a === void 0 ? void 0 : _a.show,
-                            ...displayOnWebhook.show,
+                            resume: ['webhook'],
+                            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.',
+                        },
+                    ],
+                    default: 'firstEntryJson',
+                    description: 'What data should be returned. If it should return all the items as array or only the first item as object.',
                 },
                 {
-                    ...description_1.responseBinaryPropertyNameProperty,
+                    displayName: 'Property Name',
+                    name: 'responseBinaryPropertyName',
+                    type: 'string',
+                    required: true,
+                    default: 'data',
                     displayOptions: {
                         show: {
-                            ...(_b = description_1.responseBinaryPropertyNameProperty.displayOptions) === null || _b === void 0 ? void 0 : _b.show,
-                            ...displayOnWebhook.show,
+                            resume: ['webhook'],
+                            responseData: ['firstEntryBinary'],
                         },
                     },
+                    description: 'Name of the binary property to return',
                 },
                 {
                     displayName: 'Limit Wait Time',
@@ -168,7 +333,11 @@ class Wait extends Webhook_node_1.Webhook {
                     type: 'boolean',
                     default: false,
                     description: 'If no webhook call is received, the workflow will automatically resume execution after the specified limit type',
-                    displayOptions: displayOnWebhook,
+                    displayOptions: {
+                        show: {
+                            resume: ['webhook'],
+                        },
+                    },
                 },
                 {
                     displayName: 'Limit Type',
@@ -179,7 +348,7 @@ class Wait extends Webhook_node_1.Webhook {
                     displayOptions: {
                         show: {
                             limitWaitTime: [true],
-                            ...displayOnWebhook.show,
+                            resume: ['webhook'],
                         },
                     },
                     options: [
@@ -203,7 +372,7 @@ class Wait extends Webhook_node_1.Webhook {
                         show: {
                             limitType: ['afterTimeInterval'],
                             limitWaitTime: [true],
-                            ...displayOnWebhook.show,
+                            resume: ['webhook'],
                         },
                     },
                     typeOptions: {
@@ -221,7 +390,7 @@ class Wait extends Webhook_node_1.Webhook {
                         show: {
                             limitType: ['afterTimeInterval'],
                             limitWaitTime: [true],
-                            ...displayOnWebhook.show,
+                            resume: ['webhook'],
                         },
                     },
                     options: [
@@ -253,17 +422,128 @@ class Wait extends Webhook_node_1.Webhook {
                         show: {
                             limitType: ['atSpecifiedTime'],
                             limitWaitTime: [true],
-                            ...displayOnWebhook.show,
+                            resume: ['webhook'],
                         },
                     },
                     default: '',
                     description: 'Continue execution after the specified date and time',
                 },
                 {
-                    ...description_1.optionsProperty,
-                    displayOptions: displayOnWebhook,
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    displayOptions: {
+                        show: {
+                            resume: ['webhook'],
+                        },
+                    },
+                    placeholder: 'Add Option',
+                    default: {},
                     options: [
-                        ...description_1.optionsProperty.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',
+                            displayOptions: {
+                                show: {
+                                    binaryData: [true],
+                                },
+                            },
+                            description: 'Name of the binary property to which to write the data of the received file. 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: 'Response Data',
+                            name: 'responseData',
+                            type: 'string',
+                            displayOptions: {
+                                show: {
+                                    '/responseMode': ['onReceived'],
+                                },
+                            },
+                            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',
+                        },
                         {
                             displayName: 'Webhook Suffix',
                             name: 'webhookSuffix',
@@ -277,15 +557,186 @@ class Wait extends Webhook_node_1.Webhook {
             ],
         };
     }
-    async execute(context) {
-        const resume = context.getNodeParameter('resume', 0);
+    async webhook() {
+        var _a;
+        const incomingAuthentication = this.getNodeParameter('incomingAuthentication');
+        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);
+        }
+        if (incomingAuthentication === 'basicAuth') {
+            let httpBasicAuth;
+            try {
+                httpBasicAuth = await this.getCredentials('httpBasicAuth');
+            }
+            catch (error) {
+            }
+            if (httpBasicAuth === undefined || !httpBasicAuth.user || !httpBasicAuth.password) {
+                return authorizationError(resp, realm, 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);
+            }
+        }
+        else if (incomingAuthentication === 'headerAuth') {
+            let httpHeaderAuth;
+            try {
+                httpHeaderAuth = await this.getCredentials('httpHeaderAuth');
+            }
+            catch (error) {
+            }
+            if (httpHeaderAuth === undefined || !httpHeaderAuth.name || !httpHeaderAuth.value) {
+                return authorizationError(resp, realm, 500, 'No authentication data defined on node!');
+            }
+            const headerName = httpHeaderAuth.name.toLowerCase();
+            const headerValue = httpHeaderAuth.value;
+            if (!headers.hasOwnProperty(headerName) ||
+                headers[headerName] !== headerValue) {
+                return authorizationError(resp, realm, 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));
+                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,
+                },
+            };
+        }
+        let webhookResponse;
+        if (options.responseData) {
+            webhookResponse = options.responseData;
+        }
+        return {
+            webhookResponse,
+            workflowData: [[response]],
+        };
+    }
+    async execute() {
+        const resume = this.getNodeParameter('resume', 0);
         if (resume === 'webhook') {
-            return this.handleWebhookResume(context);
+            let waitTill = new Date(n8n_workflow_1.WAIT_TIME_UNLIMITED);
+            const limitWaitTime = this.getNodeParameter('limitWaitTime', 0);
+            if (limitWaitTime === true) {
+                const limitType = this.getNodeParameter('limitType', 0);
+                if (limitType === 'afterTimeInterval') {
+                    let waitAmount = this.getNodeParameter('resumeAmount', 0);
+                    const resumeUnit = this.getNodeParameter('resumeUnit', 0);
+                    if (resumeUnit === 'minutes') {
+                        waitAmount *= 60;
+                    }
+                    if (resumeUnit === 'hours') {
+                        waitAmount *= 60 * 60;
+                    }
+                    if (resumeUnit === 'days') {
+                        waitAmount *= 60 * 60 * 24;
+                    }
+                    waitAmount *= 1000;
+                    waitTill = new Date(new Date().getTime() + waitAmount);
+                }
+                else {
+                    waitTill = new Date(this.getNodeParameter('maxDateAndTime', 0));
+                }
+            }
+            await this.putExecutionToWait(waitTill);
+            return [this.getInputData()];
         }
         let waitTill;
         if (resume === 'timeInterval') {
-            const unit = context.getNodeParameter('unit', 0);
-            let waitAmount = context.getNodeParameter('amount', 0);
+            const unit = this.getNodeParameter('unit', 0);
+            let waitAmount = this.getNodeParameter('amount', 0);
             if (unit === 'minutes') {
                 waitAmount *= 60;
             }
@@ -299,48 +750,19 @@ class Wait extends Webhook_node_1.Webhook {
             waitTill = new Date(new Date().getTime() + waitAmount);
         }
         else {
-            const dateTime = context.getNodeParameter('dateTime', 0);
+            const dateTime = this.getNodeParameter('dateTime', 0);
             waitTill = new Date(dateTime);
         }
         const waitValue = Math.max(waitTill.getTime() - new Date().getTime(), 0);
         if (waitValue < 65000) {
             return new Promise((resolve, _reject) => {
                 setTimeout(() => {
-                    resolve([context.getInputData()]);
+                    resolve([this.getInputData()]);
                 }, waitValue);
             });
         }
-        return this.putToWait(context, waitTill);
-    }
-    async handleWebhookResume(context) {
-        let waitTill = new Date(n8n_workflow_1.WAIT_TIME_UNLIMITED);
-        const limitWaitTime = context.getNodeParameter('limitWaitTime', 0);
-        if (limitWaitTime === true) {
-            const limitType = context.getNodeParameter('limitType', 0);
-            if (limitType === 'afterTimeInterval') {
-                let waitAmount = context.getNodeParameter('resumeAmount', 0);
-                const resumeUnit = context.getNodeParameter('resumeUnit', 0);
-                if (resumeUnit === 'minutes') {
-                    waitAmount *= 60;
-                }
-                if (resumeUnit === 'hours') {
-                    waitAmount *= 60 * 60;
-                }
-                if (resumeUnit === 'days') {
-                    waitAmount *= 60 * 60 * 24;
-                }
-                waitAmount *= 1000;
-                waitTill = new Date(new Date().getTime() + waitAmount);
-            }
-            else {
-                waitTill = new Date(context.getNodeParameter('maxDateAndTime', 0));
-            }
-        }
-        return this.putToWait(context, waitTill);
-    }
-    async putToWait(context, waitTill) {
-        await context.putExecutionToWait(waitTill);
-        return [context.getInputData()];
+        await this.putExecutionToWait(waitTill);
+        return [this.getInputData()];
     }
 }
 exports.Wait = Wait;