n8n-nodes-base 1.0.5 → 1.1.1

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

@@ -1,36 +1,19 @@
 "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 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 {
+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 {
     constructor() {
+        var _a, _b;
+        super(...arguments);
+        this.authPropertyName = 'incomingAuthentication';
         this.description = {
             displayName: 'Wait',
             name: 'wait',
@@ -44,69 +27,16 @@ class Wait {
             },
             inputs: ['main'],
             outputs: ['main'],
-            credentials: [
-                {
-                    name: 'httpBasicAuth',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            incomingAuthentication: ['basicAuth'],
-                        },
-                    },
-                },
-                {
-                    name: 'httpHeaderAuth',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            incomingAuthentication: ['headerAuth'],
-                        },
-                    },
-                },
-            ],
+            credentials: (0, description_1.credentialsProperty)(this.authPropertyName),
             webhooks: [
                 {
-                    name: 'default',
-                    httpMethod: '={{$parameter["httpMethod"]}}',
-                    isFullPath: true,
-                    responseCode: '={{$parameter["responseCode"]}}',
-                    responseMode: '={{$parameter["responseMode"]}}',
+                    ...description_1.defaultWebhookDescription,
                     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',
@@ -131,6 +61,11 @@ class Wait {
                     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',
@@ -193,139 +128,39 @@ class Wait {
                     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: {
-                        show: {
-                            resume: ['webhook'],
-                        },
-                    },
+                    displayOptions: displayOnWebhook,
                     default: '',
                 },
                 {
-                    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_1.httpMethodsProperty,
+                    displayOptions: displayOnWebhook,
                     description: 'The HTTP method of the Webhook call',
                 },
                 {
-                    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.responseCodeProperty,
+                    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.responseModeProperty,
+                    displayOptions: displayOnWebhook,
                 },
                 {
-                    displayName: 'Response Data',
-                    name: 'responseData',
-                    type: 'options',
+                    ...description_1.responseDataProperty,
                     displayOptions: {
                         show: {
-                            resume: ['webhook'],
-                            responseMode: ['lastNode'],
+                            ...(_a = description_1.responseDataProperty.displayOptions) === null || _a === void 0 ? void 0 : _a.show,
+                            ...displayOnWebhook.show,
                         },
                     },
-                    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.',
                 },
                 {
-                    displayName: 'Property Name',
-                    name: 'responseBinaryPropertyName',
-                    type: 'string',
-                    required: true,
-                    default: 'data',
+                    ...description_1.responseBinaryPropertyNameProperty,
                     displayOptions: {
                         show: {
-                            resume: ['webhook'],
-                            responseData: ['firstEntryBinary'],
+                            ...(_b = description_1.responseBinaryPropertyNameProperty.displayOptions) === null || _b === void 0 ? void 0 : _b.show,
+                            ...displayOnWebhook.show,
                         },
                     },
-                    description: 'Name of the binary property to return',
                 },
                 {
                     displayName: 'Limit Wait Time',
@@ -333,11 +168,7 @@ class Wait {
                     type: 'boolean',
                     default: false,
                     description: 'If no webhook call is received, the workflow will automatically resume execution after the specified limit type',
-                    displayOptions: {
-                        show: {
-                            resume: ['webhook'],
-                        },
-                    },
+                    displayOptions: displayOnWebhook,
                 },
                 {
                     displayName: 'Limit Type',
@@ -348,7 +179,7 @@ class Wait {
                     displayOptions: {
                         show: {
                             limitWaitTime: [true],
-                            resume: ['webhook'],
+                            ...displayOnWebhook.show,
                         },
                     },
                     options: [
@@ -372,7 +203,7 @@ class Wait {
                         show: {
                             limitType: ['afterTimeInterval'],
                             limitWaitTime: [true],
-                            resume: ['webhook'],
+                            ...displayOnWebhook.show,
                         },
                     },
                     typeOptions: {
@@ -390,7 +221,7 @@ class Wait {
                         show: {
                             limitType: ['afterTimeInterval'],
                             limitWaitTime: [true],
-                            resume: ['webhook'],
+                            ...displayOnWebhook.show,
                         },
                     },
                     options: [
@@ -422,128 +253,17 @@ class Wait {
                         show: {
                             limitType: ['atSpecifiedTime'],
                             limitWaitTime: [true],
-                            resume: ['webhook'],
+                            ...displayOnWebhook.show,
                         },
                     },
                     default: '',
                     description: 'Continue execution after the specified date and time',
                 },
                 {
-                    displayName: 'Options',
-                    name: 'options',
-                    type: 'collection',
-                    displayOptions: {
-                        show: {
-                            resume: ['webhook'],
-                        },
-                    },
-                    placeholder: 'Add Option',
-                    default: {},
+                    ...description_1.optionsProperty,
+                    displayOptions: displayOnWebhook,
                     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',
-                        },
+                        ...description_1.optionsProperty.options,
                         {
                             displayName: 'Webhook Suffix',
                             name: 'webhookSuffix',
@@ -557,186 +277,15 @@ class Wait {
             ],
         };
     }
-    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);
+    async execute(context) {
+        const resume = context.getNodeParameter('resume', 0);
         if (resume === 'webhook') {
-            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()];
+            return this.handleWebhookResume(context);
         }
         let waitTill;
         if (resume === 'timeInterval') {
-            const unit = this.getNodeParameter('unit', 0);
-            let waitAmount = this.getNodeParameter('amount', 0);
+            const unit = context.getNodeParameter('unit', 0);
+            let waitAmount = context.getNodeParameter('amount', 0);
             if (unit === 'minutes') {
                 waitAmount *= 60;
             }
@@ -750,19 +299,48 @@ class Wait {
             waitTill = new Date(new Date().getTime() + waitAmount);
         }
         else {
-            const dateTime = this.getNodeParameter('dateTime', 0);
+            const dateTime = context.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([this.getInputData()]);
+                    resolve([context.getInputData()]);
                 }, waitValue);
             });
         }
-        await this.putExecutionToWait(waitTill);
-        return [this.getInputData()];
+        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()];
     }
 }
 exports.Wait = Wait;