🎨 Set up linting and formatting (#2120)

* ⬆️ Upgrade TS to 4.3.5 * 👕 Add ESLint configs * 🎨 Add Prettier config * 📦 Add deps and commands * ⚡ Adjust global .editorconfig to new ruleset * 🔥 Remove unneeded local .editorconfig * 📦 Update deps in editor-ui * 🔨 Limit Prettier to only TS files * ⚡ Add recommended VSCode extensions * 👕 Fix build * 🔥 Remove Vue setting from global config * ⚡ Disable prefer-default-export per feedback * ✏️ Add forgotten divider * 👕 Disable no-plusplus * 👕 Disable class-methods-use-this * ✏️ Alphabetize overrides * 👕 Add one-var consecutive override * ⏪ Revert one-var consecutive override This reverts commit b9252cf935659ba6d76727ad484a1d3c00008fcc. * 🎨 👕 Lint and format workflow package (#2121) * 🎨 Format /workflow package * 👕 Lint /workflow package * 🎨 Re-format /workflow package * 👕 Re-lint /workflow package * ✏️ Fix typo * ⚡ Consolidate if-checks * 🔥 Remove prefer-default-export exceptions * 🔥 Remove no-plusplus exceptions * 🔥 Remove class-methods-use-this exceptions * 🎨 👕 Lint and format node-dev package (#2122) * 🎨 Format /node-dev package * ⚡ Exclude templates from ESLint config This keeps the templates consistent with the codebase while preventing lint exceptions from being made part of the templates. * 👕 Lint /node-dev package * 🔥 Remove prefer-default-export exceptions * 🔥 Remove no-plusplus exceptions * 🎨 👕 Lint and format core package (#2123) * 🎨 Format /core package * 👕 Lint /core package * 🎨 Re-format /core package * 👕 Re-lint /core package * 🔥 Remove prefer-default-export exceptions * 🔥 Remove no-plusplus exceptions * 🔥 Remove class-methods-use-this exceptions * 🎨 👕 Lint and format cli package (#2124) * 🎨 Format /cli package * 👕 Exclude migrations from linting * 👕 Lint /cli package * 🎨 Re-format /cli package * 👕 Re-lint /cli package * 👕 Fix build * 🔥 Remove prefer-default-export exceptions * ⚡ Update exceptions in ActiveExecutions * 🔥 Remove no-plusplus exceptions * 🔥 Remove class-methods-use-this exceptions * 👕 fix lint issues * 🔧 use package specific linter, remove tslint command * 🔨 resolve build issue, sync dependencies * 🔧 change lint command Co-authored-by: Ben Hesseldieck <b.hesseldieck@gmail.com>
2025-12-18 10:31:15 +00:00 · 2021-08-29 20:58:11 +02:00
parent 223cd75685
commit 56c4c6991f
108 changed files with 11832 additions and 8416 deletions
--- a/packages/cli/src/ActiveWorkflowRunner.ts
+++ b/packages/cli/src/ActiveWorkflowRunner.ts
@@ -1,23 +1,15 @@
-import {
-	Db,
-	IActivationError,
-	IResponseCallbackData,
-	IWebhookDb,
-	IWorkflowDb,
-	IWorkflowExecutionDataProcess,
-	NodeTypes,
-	ResponseHelper,
-	WebhookHelpers,
-	WorkflowCredentials,
-	WorkflowExecuteAdditionalData,
-	WorkflowHelpers,
-	WorkflowRunner,
-} from './';
-
-import {
-	ActiveWorkflows,
-	NodeExecuteFunctions,
-} from 'n8n-core';
+/* eslint-disable prefer-spread */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-console */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { ActiveWorkflows, NodeExecuteFunctions } from 'n8n-core';

 import {
 	IExecuteData,
@@ -32,12 +24,28 @@ import {
 	Workflow,
 	WorkflowActivateMode,
 	WorkflowExecuteMode,
+	LoggerProxy as Logger,
 } from 'n8n-workflow';

 import * as express from 'express';
+
+// eslint-disable-next-line import/no-cycle
 import {
-	LoggerProxy as Logger,
-} from 'n8n-workflow';
+	Db,
+	IActivationError,
+	IResponseCallbackData,
+	IWebhookDb,
+	IWorkflowDb,
+	IWorkflowExecutionDataProcess,
+	NodeTypes,
+	ResponseHelper,
+	WebhookHelpers,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	WorkflowCredentials,
+	WorkflowExecuteAdditionalData,
+	WorkflowHelpers,
+	WorkflowRunner,
+} from '.';

 const WEBHOOK_PROD_UNREGISTERED_HINT = `The workflow must be active for a production URL to run successfully. You can activate the workflow using the toggle in the top-right of the editor. Note that unlike test URL calls, production URL calls aren't shown on the canvas (only in the executions list)`;

@@ -48,14 +56,16 @@ export class ActiveWorkflowRunner {
 		[key: string]: IActivationError;
 	} = {};

+	// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 	async init() {
-
 		// Get the active workflows from database

 		// NOTE
 		// Here I guess we can have a flag on the workflow table like hasTrigger
 		// so intead of pulling all the active wehhooks just pull the actives that have a trigger
-		const workflowsData: IWorkflowDb[] = await Db.collections.Workflow!.find({ active: true }) as IWorkflowDb[];
+		const workflowsData: IWorkflowDb[] = (await Db.collections.Workflow!.find({
+			active: true,
+		})) as IWorkflowDb[];

 		// Clear up active workflow table
 		await Db.collections.Webhook?.clear();
@@ -69,21 +79,32 @@ export class ActiveWorkflowRunner {

 			for (const workflowData of workflowsData) {
 				console.log(`   - ${workflowData.name}`);
-				Logger.debug(`Initializing active workflow "${workflowData.name}" (startup)`, { workflowName: workflowData.name, workflowId: workflowData.id });
+				Logger.debug(`Initializing active workflow "${workflowData.name}" (startup)`, {
+					workflowName: workflowData.name,
+					workflowId: workflowData.id,
+				});
 				try {
 					await this.add(workflowData.id.toString(), 'init', workflowData);
-					Logger.verbose(`Successfully started workflow "${workflowData.name}"`, { workflowName: workflowData.name, workflowId: workflowData.id });
+					Logger.verbose(`Successfully started workflow "${workflowData.name}"`, {
+						workflowName: workflowData.name,
+						workflowId: workflowData.id,
+					});
 					console.log(`     => Started`);
 				} catch (error) {
 					console.log(`     => ERROR: Workflow could not be activated:`);
+					// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
 					console.log(`               ${error.message}`);
-					Logger.error(`Unable to initialize workflow "${workflowData.name}" (startup)`, { workflowName: workflowData.name, workflowId: workflowData.id });
+					Logger.error(`Unable to initialize workflow "${workflowData.name}" (startup)`, {
+						workflowName: workflowData.name,
+						workflowId: workflowData.id,
+					});
 				}
 			}
 			Logger.verbose('Finished initializing active workflows (startup)');
 		}
 	}

+	// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 	async initWebhooks() {
 		this.activeWorkflows = new ActiveWorkflows();
 	}
@@ -104,7 +125,10 @@ export class ActiveWorkflowRunner {
 		}

 		const activeWorkflows = await this.getActiveWorkflows();
-		activeWorkflowId.push.apply(activeWorkflowId, activeWorkflows.map(workflow => workflow.id));
+		activeWorkflowId.push.apply(
+			activeWorkflowId,
+			activeWorkflows.map((workflow) => workflow.id),
+		);

 		const removePromises = [];
 		for (const workflowId of activeWorkflowId) {
@@ -112,7 +136,6 @@ export class ActiveWorkflowRunner {
 		}

 		await Promise.all(removePromises);
-		return;
 	}

 	/**
@@ -125,10 +148,19 @@ export class ActiveWorkflowRunner {
 	 * @returns {Promise<object>}
 	 * @memberof ActiveWorkflowRunner
 	 */
-	async executeWebhook(httpMethod: WebhookHttpMethod, path: string, req: express.Request, res: express.Response): Promise<IResponseCallbackData> {
+	async executeWebhook(
+		httpMethod: WebhookHttpMethod,
+		path: string,
+		req: express.Request,
+		res: express.Response,
+	): Promise<IResponseCallbackData> {
 		Logger.debug(`Received webhoook "${httpMethod}" for path "${path}"`);
 		if (this.activeWorkflows === null) {
-			throw new ResponseHelper.ResponseError('The "activeWorkflows" instance did not get initialized yet.', 404, 404);
+			throw new ResponseHelper.ResponseError(
+				'The "activeWorkflows" instance did not get initialized yet.',
+				404,
+				404,
+			);
 		}

 		// Reset request parameters
@@ -139,7 +171,10 @@ export class ActiveWorkflowRunner {
 			path = path.slice(0, -1);
 		}

-		let webhook = await Db.collections.Webhook?.findOne({ webhookPath: path, method: httpMethod }) as IWebhookDb;
+		let webhook = (await Db.collections.Webhook?.findOne({
+			webhookPath: path,
+			method: httpMethod,
+		})) as IWebhookDb;
 		let webhookId: string | undefined;

 		// check if path is dynamic
@@ -147,19 +182,30 @@ export class ActiveWorkflowRunner {
 			// check if a dynamic webhook path exists
 			const pathElements = path.split('/');
 			webhookId = pathElements.shift();
-			const dynamicWebhooks = await Db.collections.Webhook?.find({ webhookId, method: httpMethod, pathLength: pathElements.length });
+			const dynamicWebhooks = await Db.collections.Webhook?.find({
+				webhookId,
+				method: httpMethod,
+				pathLength: pathElements.length,
+			});
 			if (dynamicWebhooks === undefined || dynamicWebhooks.length === 0) {
 				// The requested webhook is not registered
-				throw new ResponseHelper.ResponseError(`The requested webhook "${httpMethod} ${path}" is not registered.`, 404, 404, WEBHOOK_PROD_UNREGISTERED_HINT);
+				throw new ResponseHelper.ResponseError(
+					`The requested webhook "${httpMethod} ${path}" is not registered.`,
+					404,
+					404,
+					WEBHOOK_PROD_UNREGISTERED_HINT,
+				);
 			}

 			let maxMatches = 0;
 			const pathElementsSet = new Set(pathElements);
 			// check if static elements match in path
 			// if more results have been returned choose the one with the most static-route matches
-			dynamicWebhooks.forEach(dynamicWebhook => {
-				const staticElements = dynamicWebhook.webhookPath.split('/').filter(ele => !ele.startsWith(':'));
-				const allStaticExist = staticElements.every(staticEle => pathElementsSet.has(staticEle));
+			dynamicWebhooks.forEach((dynamicWebhook) => {
+				const staticElements = dynamicWebhook.webhookPath
+					.split('/')
+					.filter((ele) => !ele.startsWith(':'));
+				const allStaticExist = staticElements.every((staticEle) => pathElementsSet.has(staticEle));

 				if (allStaticExist && staticElements.length > maxMatches) {
 					maxMatches = staticElements.length;
@@ -171,12 +217,20 @@ export class ActiveWorkflowRunner {
 				}
 			});
 			if (webhook === undefined) {
-				throw new ResponseHelper.ResponseError(`The requested webhook "${httpMethod} ${path}" is not registered.`, 404, 404, WEBHOOK_PROD_UNREGISTERED_HINT);
+				throw new ResponseHelper.ResponseError(
+					`The requested webhook "${httpMethod} ${path}" is not registered.`,
+					404,
+					404,
+					WEBHOOK_PROD_UNREGISTERED_HINT,
+				);
 			}

-			path = webhook!.webhookPath;
+			// @ts-ignore
+			// eslint-disable-next-line no-param-reassign
+			path = webhook.webhookPath;
 			// extracting params from path
-			webhook!.webhookPath.split('/').forEach((ele, index) => {
+			// @ts-ignore
+			webhook.webhookPath.split('/').forEach((ele, index) => {
 				if (ele.startsWith(':')) {
 					// write params to req.params
 					req.params[ele.slice(1)] = pathElements[index];
@@ -186,16 +240,33 @@ export class ActiveWorkflowRunner {

 		const workflowData = await Db.collections.Workflow!.findOne(webhook.workflowId);
 		if (workflowData === undefined) {
-			throw new ResponseHelper.ResponseError(`Could not find workflow with id "${webhook.workflowId}"`, 404, 404);
+			throw new ResponseHelper.ResponseError(
+				`Could not find workflow with id "${webhook.workflowId}"`,
+				404,
+				404,
+			);
 		}

 		const nodeTypes = NodeTypes();
-		const workflow = new Workflow({ id: webhook.workflowId.toString(), name: workflowData.name, nodes: workflowData.nodes, connections: workflowData.connections, active: workflowData.active, nodeTypes, staticData: workflowData.staticData, settings: workflowData.settings });
+		const workflow = new Workflow({
+			id: webhook.workflowId.toString(),
+			name: workflowData.name,
+			nodes: workflowData.nodes,
+			connections: workflowData.connections,
+			active: workflowData.active,
+			nodeTypes,
+			staticData: workflowData.staticData,
+			settings: workflowData.settings,
+		});

 		const additionalData = await WorkflowExecuteAdditionalData.getBase();

-		const webhookData = NodeHelpers.getNodeWebhooks(workflow, workflow.getNode(webhook.node as string) as INode, additionalData).filter((webhook) => {
-			return (webhook.httpMethod === httpMethod && webhook.path === path);
+		const webhookData = NodeHelpers.getNodeWebhooks(
+			workflow,
+			workflow.getNode(webhook.node) as INode,
+			additionalData,
+		).filter((webhook) => {
+			return webhook.httpMethod === httpMethod && webhook.path === path;
 		})[0];

 		// Get the node which has the webhook defined to know where to start from and to
@@ -208,13 +279,26 @@ export class ActiveWorkflowRunner {

 		return new Promise((resolve, reject) => {
 			const executionMode = 'webhook';
-			//@ts-ignore
-			WebhookHelpers.executeWebhook(workflow, webhookData, workflowData, workflowStartNode, executionMode, undefined, undefined, undefined, req, res, (error: Error | null, data: object) => {
-				if (error !== null) {
-					return reject(error);
-				}
-				resolve(data);
-			});
+			// @ts-ignore
+			WebhookHelpers.executeWebhook(
+				workflow,
+				webhookData,
+				workflowData,
+				workflowStartNode,
+				executionMode,
+				undefined,
+				undefined,
+				undefined,
+				req,
+				res,
+				// eslint-disable-next-line consistent-return
+				(error: Error | null, data: object) => {
+					if (error !== null) {
+						return reject(error);
+					}
+					resolve(data);
+				},
+			);
 		});
 	}

@@ -226,10 +310,10 @@ export class ActiveWorkflowRunner {
 	 * @memberof ActiveWorkflowRunner
 	 */
 	async getWebhookMethods(path: string): Promise<string[]> {
-		const webhooks = await Db.collections.Webhook?.find({ webhookPath: path }) as IWebhookDb[];
+		const webhooks = (await Db.collections.Webhook?.find({ webhookPath: path })) as IWebhookDb[];

 		// Gather all request methods in string array
-		const webhookMethods: string[] = webhooks.map(webhook => webhook.method);
+		const webhookMethods: string[] = webhooks.map((webhook) => webhook.method);
 		return webhookMethods;
 	}

@@ -240,11 +324,15 @@ export class ActiveWorkflowRunner {
 	 * @memberof ActiveWorkflowRunner
 	 */
 	async getActiveWorkflows(): Promise<IWorkflowDb[]> {
-		const activeWorkflows = await Db.collections.Workflow?.find({ where: { active: true }, select: ['id'] }) as IWorkflowDb[];
-		return activeWorkflows.filter(workflow => this.activationErrors[workflow.id.toString()] === undefined);
+		const activeWorkflows = (await Db.collections.Workflow?.find({
+			where: { active: true },
+			select: ['id'],
+		})) as IWorkflowDb[];
+		return activeWorkflows.filter(
+			(workflow) => this.activationErrors[workflow.id.toString()] === undefined,
+		);
 	}

-
 	/**
 	 * Returns if the workflow is active
 	 *
@@ -253,8 +341,8 @@ export class ActiveWorkflowRunner {
 	 * @memberof ActiveWorkflowRunner
 	 */
 	async isActive(id: string): Promise<boolean> {
-		const workflow = await Db.collections.Workflow?.findOne({ id: Number(id) }) as IWorkflowDb;
-		return workflow?.active as boolean;
+		const workflow = (await Db.collections.Workflow?.findOne({ id: Number(id) })) as IWorkflowDb;
+		return workflow?.active;
 	}

 	/**
@@ -281,12 +369,16 @@ export class ActiveWorkflowRunner {
 	 * @returns {Promise<void>}
 	 * @memberof ActiveWorkflowRunner
 	 */
-	async addWorkflowWebhooks(workflow: Workflow, additionalData: IWorkflowExecuteAdditionalDataWorkflow, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): Promise<void> {
+	async addWorkflowWebhooks(
+		workflow: Workflow,
+		additionalData: IWorkflowExecuteAdditionalDataWorkflow,
+		mode: WorkflowExecuteMode,
+		activation: WorkflowActivateMode,
+	): Promise<void> {
 		const webhooks = WebhookHelpers.getWorkflowWebhooks(workflow, additionalData, undefined, true);
 		let path = '' as string | undefined;

 		for (const webhookData of webhooks) {
-
 			const node = workflow.getNode(webhookData.node) as INode;
 			node.name = webhookData.node;

@@ -312,18 +404,35 @@ export class ActiveWorkflowRunner {
 			}

 			try {
+				// eslint-disable-next-line no-await-in-loop
 				await Db.collections.Webhook?.insert(webhook);
-				const webhookExists = await workflow.runWebhookMethod('checkExists', webhookData, NodeExecuteFunctions, mode, activation, false);
+				const webhookExists = await workflow.runWebhookMethod(
+					'checkExists',
+					webhookData,
+					NodeExecuteFunctions,
+					mode,
+					activation,
+					false,
+				);
 				if (webhookExists !== true) {
 					// If webhook does not exist yet create it
-					await workflow.runWebhookMethod('create', webhookData, NodeExecuteFunctions, mode, activation, false);
+					await workflow.runWebhookMethod(
+						'create',
+						webhookData,
+						NodeExecuteFunctions,
+						mode,
+						activation,
+						false,
+					);
 				}
-
 			} catch (error) {
 				try {
 					await this.removeWorkflowWebhooks(workflow.id as string);
 				} catch (error) {
-					console.error(`Could not remove webhooks of workflow "${workflow.id}" because of error: "${error.message}"`);
+					console.error(
+						// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+						`Could not remove webhooks of workflow "${workflow.id}" because of error: "${error.message}"`,
+					);
 				}

 				let errorMessage = '';
@@ -337,6 +446,7 @@ export class ActiveWorkflowRunner {
 					// it's a error runnig the webhook methods (checkExists, create)
 					errorMessage = error.detail;
 				} else {
+					// eslint-disable-next-line @typescript-eslint/no-unused-vars
 					errorMessage = error.message;
 				}

@@ -347,7 +457,6 @@ export class ActiveWorkflowRunner {
 		await WorkflowHelpers.saveStaticData(workflow);
 	}

-
 	/**
 	 * Remove all the webhooks of the workflow
 	 *
@@ -362,7 +471,16 @@ export class ActiveWorkflowRunner {
 		}

 		const nodeTypes = NodeTypes();
-		const workflow = new Workflow({ id: workflowId, name: workflowData.name, nodes: workflowData.nodes, connections: workflowData.connections, active: workflowData.active, nodeTypes, staticData: workflowData.staticData, settings: workflowData.settings });
+		const workflow = new Workflow({
+			id: workflowId,
+			name: workflowData.name,
+			nodes: workflowData.nodes,
+			connections: workflowData.connections,
+			active: workflowData.active,
+			nodeTypes,
+			staticData: workflowData.staticData,
+			settings: workflowData.settings,
+		});

 		const mode = 'internal';

@@ -371,7 +489,14 @@ export class ActiveWorkflowRunner {
 		const webhooks = WebhookHelpers.getWorkflowWebhooks(workflow, additionalData, undefined, true);

 		for (const webhookData of webhooks) {
-			await workflow.runWebhookMethod('delete', webhookData, NodeExecuteFunctions, mode, 'update', false);
+			await workflow.runWebhookMethod(
+				'delete',
+				webhookData,
+				NodeExecuteFunctions,
+				mode,
+				'update',
+				false,
+			);
 		}

 		await WorkflowHelpers.saveStaticData(workflow);
@@ -394,7 +519,14 @@ export class ActiveWorkflowRunner {
 	 * @returns
 	 * @memberof ActiveWorkflowRunner
 	 */
-	runWorkflow(workflowData: IWorkflowDb, node: INode, data: INodeExecutionData[][], additionalData: IWorkflowExecuteAdditionalDataWorkflow, mode: WorkflowExecuteMode) {
+	// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+	async runWorkflow(
+		workflowData: IWorkflowDb,
+		node: INode,
+		data: INodeExecutionData[][],
+		additionalData: IWorkflowExecuteAdditionalDataWorkflow,
+		mode: WorkflowExecuteMode,
+	) {
 		const nodeExecutionStack: IExecuteData[] = [
 			{
 				node,
@@ -427,7 +559,6 @@ export class ActiveWorkflowRunner {
 		return workflowRunner.run(runData, true);
 	}

-
 	/**
 	 * Return poll function which gets the global functions from n8n-core
 	 * and overwrites the __emit to be able to start it in subprocess
@@ -438,18 +569,30 @@ export class ActiveWorkflowRunner {
 	 * @returns {IGetExecutePollFunctions}
 	 * @memberof ActiveWorkflowRunner
 	 */
-	getExecutePollFunctions(workflowData: IWorkflowDb, additionalData: IWorkflowExecuteAdditionalDataWorkflow, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): IGetExecutePollFunctions {
-		return ((workflow: Workflow, node: INode) => {
-			const returnFunctions = NodeExecuteFunctions.getExecutePollFunctions(workflow, node, additionalData, mode, activation);
+	getExecutePollFunctions(
+		workflowData: IWorkflowDb,
+		additionalData: IWorkflowExecuteAdditionalDataWorkflow,
+		mode: WorkflowExecuteMode,
+		activation: WorkflowActivateMode,
+	): IGetExecutePollFunctions {
+		return (workflow: Workflow, node: INode) => {
+			const returnFunctions = NodeExecuteFunctions.getExecutePollFunctions(
+				workflow,
+				node,
+				additionalData,
+				mode,
+				activation,
+			);
+			// eslint-disable-next-line no-underscore-dangle
 			returnFunctions.__emit = (data: INodeExecutionData[][]): void => {
+				// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
 				Logger.debug(`Received event to trigger execution for workflow "${workflow.name}"`);
 				this.runWorkflow(workflowData, node, data, additionalData, mode);
 			};
 			return returnFunctions;
-		});
+		};
 	}

-
 	/**
 	 * Return trigger function which gets the global functions from n8n-core
 	 * and overwrites the emit to be able to start it in subprocess
@@ -460,16 +603,31 @@ export class ActiveWorkflowRunner {
 	 * @returns {IGetExecuteTriggerFunctions}
 	 * @memberof ActiveWorkflowRunner
 	 */
-	getExecuteTriggerFunctions(workflowData: IWorkflowDb, additionalData: IWorkflowExecuteAdditionalDataWorkflow, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): IGetExecuteTriggerFunctions {
-		return ((workflow: Workflow, node: INode) => {
-			const returnFunctions = NodeExecuteFunctions.getExecuteTriggerFunctions(workflow, node, additionalData, mode, activation);
+	getExecuteTriggerFunctions(
+		workflowData: IWorkflowDb,
+		additionalData: IWorkflowExecuteAdditionalDataWorkflow,
+		mode: WorkflowExecuteMode,
+		activation: WorkflowActivateMode,
+	): IGetExecuteTriggerFunctions {
+		return (workflow: Workflow, node: INode) => {
+			const returnFunctions = NodeExecuteFunctions.getExecuteTriggerFunctions(
+				workflow,
+				node,
+				additionalData,
+				mode,
+				activation,
+			);
 			returnFunctions.emit = (data: INodeExecutionData[][]): void => {
+				// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
 				Logger.debug(`Received trigger for workflow "${workflow.name}"`);
 				WorkflowHelpers.saveStaticData(workflow);
-				this.runWorkflow(workflowData, node, data, additionalData, mode).catch((err) => console.error(err));
+				// eslint-disable-next-line id-denylist
+				this.runWorkflow(workflowData, node, data, additionalData, mode).catch((err) =>
+					console.error(err),
+				);
 			};
 			return returnFunctions;
-		});
+		};
 	}

 	/**
@@ -480,7 +638,11 @@ export class ActiveWorkflowRunner {
 	 * @returns {Promise<void>}
 	 * @memberof ActiveWorkflowRunner
 	 */
-	async add(workflowId: string, activation: WorkflowActivateMode, workflowData?: IWorkflowDb): Promise<void> {
+	async add(
+		workflowId: string,
+		activation: WorkflowActivateMode,
+		workflowData?: IWorkflowDb,
+	): Promise<void> {
 		if (this.activeWorkflows === null) {
 			throw new Error(`The "activeWorkflows" instance did not get initialized yet.`);
 		}
@@ -488,33 +650,69 @@ export class ActiveWorkflowRunner {
 		let workflowInstance: Workflow;
 		try {
 			if (workflowData === undefined) {
-				workflowData = await Db.collections.Workflow!.findOne(workflowId) as IWorkflowDb;
+				workflowData = (await Db.collections.Workflow!.findOne(workflowId)) as IWorkflowDb;
 			}

 			if (!workflowData) {
 				throw new Error(`Could not find workflow with id "${workflowId}".`);
 			}
 			const nodeTypes = NodeTypes();
-			workflowInstance = new Workflow({ id: workflowId, name: workflowData.name, nodes: workflowData.nodes, connections: workflowData.connections, active: workflowData.active, nodeTypes, staticData: workflowData.staticData, settings: workflowData.settings });
+			workflowInstance = new Workflow({
+				id: workflowId,
+				name: workflowData.name,
+				nodes: workflowData.nodes,
+				connections: workflowData.connections,
+				active: workflowData.active,
+				nodeTypes,
+				staticData: workflowData.staticData,
+				settings: workflowData.settings,
+			});

-			const canBeActivated = workflowInstance.checkIfWorkflowCanBeActivated(['n8n-nodes-base.start']);
-			if (canBeActivated === false) {
+			const canBeActivated = workflowInstance.checkIfWorkflowCanBeActivated([
+				'n8n-nodes-base.start',
+			]);
+			if (!canBeActivated) {
 				Logger.error(`Unable to activate workflow "${workflowData.name}"`);
-				throw new Error(`The workflow can not be activated because it does not contain any nodes which could start the workflow. Only workflows which have trigger or webhook nodes can be activated.`);
+				throw new Error(
+					`The workflow can not be activated because it does not contain any nodes which could start the workflow. Only workflows which have trigger or webhook nodes can be activated.`,
+				);
 			}

 			const mode = 'trigger';
 			const additionalData = await WorkflowExecuteAdditionalData.getBase();
-			const getTriggerFunctions = this.getExecuteTriggerFunctions(workflowData, additionalData, mode, activation);
-			const getPollFunctions = this.getExecutePollFunctions(workflowData, additionalData, mode, activation);
+			const getTriggerFunctions = this.getExecuteTriggerFunctions(
+				workflowData,
+				additionalData,
+				mode,
+				activation,
+			);
+			const getPollFunctions = this.getExecutePollFunctions(
+				workflowData,
+				additionalData,
+				mode,
+				activation,
+			);

 			// Add the workflows which have webhooks defined
 			await this.addWorkflowWebhooks(workflowInstance, additionalData, mode, activation);

-			if (workflowInstance.getTriggerNodes().length !== 0
-				|| workflowInstance.getPollNodes().length !== 0) {
-				await this.activeWorkflows.add(workflowId, workflowInstance, additionalData, mode, activation, getTriggerFunctions, getPollFunctions);
-				Logger.verbose(`Successfully activated workflow "${workflowData.name}"`, { workflowId, workflowName: workflowData.name });
+			if (
+				workflowInstance.getTriggerNodes().length !== 0 ||
+				workflowInstance.getPollNodes().length !== 0
+			) {
+				await this.activeWorkflows.add(
+					workflowId,
+					workflowInstance,
+					additionalData,
+					mode,
+					activation,
+					getTriggerFunctions,
+					getPollFunctions,
+				);
+				Logger.verbose(`Successfully activated workflow "${workflowData.name}"`, {
+					workflowId,
+					workflowName: workflowData.name,
+				});
 			}

 			if (this.activationErrors[workflowId] !== undefined) {
@@ -548,13 +746,15 @@ export class ActiveWorkflowRunner {
 	 * @memberof ActiveWorkflowRunner
 	 */
 	async remove(workflowId: string): Promise<void> {
-
 		if (this.activeWorkflows !== null) {
 			// Remove all the webhooks of the workflow
 			try {
 				await this.removeWorkflowWebhooks(workflowId);
 			} catch (error) {
-				console.error(`Could not remove webhooks of workflow "${workflowId}" because of error: "${error.message}"`);
+				console.error(
+					// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+					`Could not remove webhooks of workflow "${workflowId}" because of error: "${error.message}"`,
+				);
 			}

 			if (this.activationErrors[workflowId] !== undefined) {
@@ -576,8 +776,6 @@ export class ActiveWorkflowRunner {
 	}
 }

-
-
 let workflowRunnerInstance: ActiveWorkflowRunner | undefined;

 export function getInstance(): ActiveWorkflowRunner {