@n8n/eslint-plugin-community-nodes 0.2.0

package/src/rules/no-deprecated-workflow-functions.test.ts

@@ -0,0 +1,117 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { NoDeprecatedWorkflowFunctionsRule } from './no-deprecated-workflow-functions.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-deprecated-workflow-functions', NoDeprecatedWorkflowFunctionsRule, {
+	valid: [
+		{
+			name: 'using recommended functions and types',
+			code: `
+import { IHttpRequestOptions } from 'n8n-workflow';
+
+const requestOptions: IHttpRequestOptions = {
+	method: 'GET',
+	url: 'https://example.com',
+};
+
+const response1 = await this.helpers.httpRequest(requestOptions);
+const response2 = await this.helpers.httpRequestWithAuthentication.call(this, 'oAuth2Api', {
+	method: 'POST',
+	url: 'https://api.example.com/data',
+});`,
+		},
+		{
+			name: 'functions with similar names should not trigger',
+			code: `
+import { request } from 'axios';
+
+const result = await this.helpers.requestSomething();
+const response = await request('https://api.example.com');
+const config = { request: 'some value' };
+
+// Other objects with helpers property should not trigger
+const otherObject = {
+	helpers: {
+		request: () => 'not n8n',
+		requestWithAuthentication: () => 'not n8n'
+	}
+};
+const result2 = otherObject.helpers.request();`,
+		},
+		{
+			name: 'types with same name from other modules should not trigger',
+			code: `
+import { IRequestOptions } from 'some-other-package';
+
+function test(options: IRequestOptions) {
+	return options.url;
+}`,
+		},
+	],
+	invalid: [
+		{
+			name: 'deprecated request functions',
+			code: `
+const response1 = await this.helpers.request('https://example.com/1');
+const response2 = await this.helpers.requestWithAuthentication.call(this, 'oauth', options);
+const response3 = await this.helpers.requestOAuth2.call(this, 'google', options);`,
+			errors: [
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: { functionName: 'request', replacement: 'httpRequest' },
+				},
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: {
+						functionName: 'requestWithAuthentication',
+						replacement: 'httpRequestWithAuthentication',
+					},
+				},
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: { functionName: 'requestOAuth2', replacement: 'httpRequestWithAuthentication' },
+				},
+			],
+		},
+		{
+			name: 'deprecated types',
+			code: `
+import { IRequestOptions } from 'n8n-workflow';
+
+function makeRequest(options: IRequestOptions): Promise<any> {
+	return this.helpers.request(options);
+}`,
+			errors: [
+				{
+					messageId: 'deprecatedType',
+					data: { typeName: 'IRequestOptions', replacement: 'IHttpRequestOptions' },
+				},
+				{
+					messageId: 'deprecatedType',
+					data: { typeName: 'IRequestOptions', replacement: 'IHttpRequestOptions' },
+				},
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: { functionName: 'request', replacement: 'httpRequest' },
+				},
+			],
+		},
+		{
+			name: 'functions without replacement',
+			code: `
+const result = await this.helpers.copyBinaryFile();
+return this.helpers.prepareOutputData([{ json: response }]);`,
+			errors: [
+				{
+					messageId: 'deprecatedWithoutReplacement',
+					data: { functionName: 'copyBinaryFile' },
+				},
+				{
+					messageId: 'deprecatedWithoutReplacement',
+					data: { functionName: 'prepareOutputData' },
+				},
+			],
+		},
+	],
+});

package/src/rules/no-deprecated-workflow-functions.ts

@@ -0,0 +1,166 @@
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+
+const DEPRECATED_FUNCTIONS = {
+	request: 'httpRequest',
+	requestWithAuthentication: 'httpRequestWithAuthentication',
+	requestOAuth1: 'httpRequestWithAuthentication',
+	requestOAuth2: 'httpRequestWithAuthentication',
+	copyBinaryFile: null,
+	prepareOutputData: null,
+} as const;
+
+const DEPRECATED_TYPES = {
+	IRequestOptions: 'IHttpRequestOptions',
+} as const;
+
+function isDeprecatedFunctionName(name: string): name is keyof typeof DEPRECATED_FUNCTIONS {
+	return name in DEPRECATED_FUNCTIONS;
+}
+
+function isDeprecatedTypeName(name: string): name is keyof typeof DEPRECATED_TYPES {
+	return name in DEPRECATED_TYPES;
+}
+
+export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.withoutDocs({
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow usage of deprecated functions and types from n8n-workflow package',
+		},
+		messages: {
+			deprecatedRequestFunction:
+				"'{{ functionName }}' is deprecated. Use '{{ replacement }}' instead for better authentication support and consistency.",
+			deprecatedFunction: "'{{ functionName }}' is deprecated and should be avoided. {{ message }}",
+			deprecatedType: "'{{ typeName }}' is deprecated. Use '{{ replacement }}' instead.",
+			deprecatedWithoutReplacement:
+				"'{{ functionName }}' is deprecated and should be removed or replaced with alternative implementation.",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		const n8nWorkflowTypes = new Set<string>();
+
+		return {
+			ImportDeclaration(node) {
+				if (node.source.value === 'n8n-workflow') {
+					node.specifiers.forEach((specifier) => {
+						if (specifier.type === 'ImportSpecifier' && specifier.imported.type === 'Identifier') {
+							n8nWorkflowTypes.add(specifier.local.name);
+						}
+					});
+				}
+			},
+
+			MemberExpression(node) {
+				if (node.property.type === 'Identifier' && isDeprecatedFunctionName(node.property.name)) {
+					if (!isThisHelpersAccess(node)) {
+						return;
+					}
+
+					const functionName = node.property.name;
+					const replacement = DEPRECATED_FUNCTIONS[functionName];
+
+					if (replacement) {
+						const messageId = functionName.includes('request')
+							? 'deprecatedRequestFunction'
+							: 'deprecatedFunction';
+
+						context.report({
+							node: node.property,
+							messageId,
+							data: {
+								functionName,
+								replacement,
+								message: getDeprecationMessage(functionName),
+							},
+						});
+					} else {
+						context.report({
+							node: node.property,
+							messageId: 'deprecatedWithoutReplacement',
+							data: {
+								functionName,
+							},
+						});
+					}
+				}
+			},
+
+			TSTypeReference(node) {
+				if (
+					node.typeName.type === 'Identifier' &&
+					isDeprecatedTypeName(node.typeName.name) &&
+					n8nWorkflowTypes.has(node.typeName.name)
+				) {
+					const typeName = node.typeName.name;
+					const replacement = DEPRECATED_TYPES[typeName];
+
+					context.report({
+						node: node.typeName,
+						messageId: 'deprecatedType',
+						data: {
+							typeName,
+							replacement,
+						},
+					});
+				}
+			},
+
+			ImportSpecifier(node) {
+				// Check if this import is from n8n-workflow by looking at the parent ImportDeclaration
+				const importDeclaration = node.parent;
+				if (
+					importDeclaration?.type === 'ImportDeclaration' &&
+					importDeclaration.source.value === 'n8n-workflow' &&
+					node.imported.type === 'Identifier' &&
+					isDeprecatedTypeName(node.imported.name)
+				) {
+					const typeName = node.imported.name;
+					const replacement = DEPRECATED_TYPES[typeName];
+
+					context.report({
+						node: node.imported,
+						messageId: 'deprecatedType',
+						data: {
+							typeName,
+							replacement,
+						},
+					});
+				}
+			},
+		};
+	},
+});
+
+/**
+ * Check if the MemberExpression follows the this.helpers.* pattern
+ */
+function isThisHelpersAccess(node: TSESTree.MemberExpression): boolean {
+	if (node.object?.type === 'MemberExpression') {
+		const outerObject = node.object;
+		return (
+			outerObject.object?.type === 'ThisExpression' &&
+			outerObject.property?.type === 'Identifier' &&
+			outerObject.property.name === 'helpers'
+		);
+	}
+	return false;
+}
+
+function getDeprecationMessage(functionName: string): string {
+	switch (functionName) {
+		case 'request':
+			return 'Use httpRequest for better type safety and consistency.';
+		case 'requestWithAuthentication':
+		case 'requestOAuth1':
+		case 'requestOAuth2':
+			return 'Use httpRequestWithAuthentication which provides unified authentication handling.';
+		case 'copyBinaryFile':
+			return 'This function has been removed. Handle binary data directly.';
+		case 'prepareOutputData':
+			return 'This function is deprecated. Return data directly from execute method.';
+		default:
+			return 'This function is deprecated and should be avoided.';
+	}
+}

package/src/rules/no-restricted-globals.test.ts

@@ -0,0 +1,135 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { NoRestrictedGlobalsRule } from './no-restricted-globals.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-restricted-globals', NoRestrictedGlobalsRule, {
+	valid: [
+		{
+			code: 'const result = someFunction();',
+		},
+		{
+			code: 'window.setTimeout(() => {}, 1000);',
+		},
+		{
+			code: 'const obj = { global: "allowed" };',
+		},
+		{
+			code: 'function process() { return "allowed"; }',
+		},
+		{
+			code: 'console.clearInterval;',
+		},
+		{
+			code: 'const obj = { __dirname: "allowed", Buffer: "allowed", require: "allowed" };',
+		},
+		{
+			code: 'function globalThis() { return "allowed"; }',
+		},
+		{
+			code: 'const helper = require("./helper");',
+		},
+		{
+			name: 'variable declarations should be allowed',
+			code: 'const process = "my-process"; let global = "my-global";',
+		},
+		{
+			name: 'function parameters should be allowed',
+			code: 'function test(process, global, setTimeout) { return process; }',
+		},
+		{
+			name: 'arrow function parameters should be allowed',
+			code: 'const fn = (process, global) => process + global;',
+		},
+		{
+			name: 'destructuring should be allowed',
+			code: 'const { process, global } = someObject; const [setTimeout] = someArray;',
+		},
+		{
+			name: 'class methods should be allowed',
+			code: 'class MyClass { process() {} global = "value"; }',
+		},
+		{
+			name: 'import should be allowed',
+			code: 'import { process } from "./utils";',
+		},
+		{
+			name: 'function expressions should be allowed',
+			code: 'const fn = function process() {}; const fn2 = function global() {};',
+		},
+		{
+			name: 'locally declared variables should not trigger false positives',
+			code: `
+const process = require('process');
+const global = {};
+const setTimeout = () => {};
+function clearInterval() {}
+let setInterval;
+var __dirname = '/path';
+const __filename = 'file.js';
+			`,
+		},
+	],
+	invalid: [
+		{
+			code: 'const pid = process.pid;',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'process' } }],
+		},
+		{
+			code: 'global.myVar = "test";',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'global' } }],
+		},
+		{
+			code: 'setTimeout(() => {}, 1000);',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'setTimeout' } }],
+		},
+		{
+			code: 'clearInterval(timer);',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'clearInterval' } }],
+		},
+		{
+			code: 'clearTimeout(timer);',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'clearTimeout' } }],
+		},
+		{
+			code: 'setInterval(() => {}, 1000);',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'setInterval' } }],
+		},
+		{
+			code: `
+const fn = () => {
+	process.exit(0);
+	global.something = true;
+};`,
+			errors: [
+				{ messageId: 'restrictedGlobal', data: { name: 'process' } },
+				{ messageId: 'restrictedGlobal', data: { name: 'global' } },
+			],
+		},
+		{
+			name: 'SECURITY: __dirname usage',
+			code: 'const currentDir = __dirname;',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: '__dirname' } }],
+		},
+		{
+			name: 'SECURITY: __filename usage',
+			code: 'console.log(__filename);',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: '__filename' } }],
+		},
+		{
+			name: 'SECURITY: globalThis usage',
+			code: 'globalThis.myVar = "test";',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'globalThis' } }],
+		},
+		{
+			name: 'SECURITY: setImmediate usage',
+			code: 'setImmediate(() => {});',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'setImmediate' } }],
+		},
+		{
+			name: 'SECURITY: clearImmediate usage',
+			code: 'clearImmediate(immediate);',
+			errors: [{ messageId: 'restrictedGlobal', data: { name: 'clearImmediate' } }],
+		},
+	],
+});

package/src/rules/no-restricted-globals.ts

@@ -0,0 +1,71 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import type { TSESLint } from '@typescript-eslint/utils';
+
+const restrictedGlobals = [
+	'clearInterval',
+	'clearTimeout',
+	'global',
+	'globalThis',
+	'process',
+	'setInterval',
+	'setTimeout',
+	'setImmediate',
+	'clearImmediate',
+	'__dirname',
+	'__filename',
+];
+
+export const NoRestrictedGlobalsRule = ESLintUtils.RuleCreator.withoutDocs({
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow usage of restricted global variables in community nodes.',
+		},
+		messages: {
+			restrictedGlobal: "Use of restricted global '{{ name }}' is not allowed",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		function checkReference(ref: TSESLint.Scope.Reference, name: string) {
+			const { parent } = ref.identifier;
+
+			// Skip property access (like console.process - we want process.exit but not obj.process)
+			if (
+				parent?.type === 'MemberExpression' &&
+				parent.property === ref.identifier &&
+				!parent.computed
+			) {
+				return;
+			}
+
+			context.report({
+				node: ref.identifier,
+				messageId: 'restrictedGlobal',
+				data: { name },
+			});
+		}
+
+		return {
+			Program() {
+				const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
+
+				const allReferences = [
+					...globalScope.variables
+						.filter(
+							(variable) => restrictedGlobals.includes(variable.name) && variable.defs.length === 0, // No definitions means it's a global
+						)
+						.flatMap((variable) =>
+							variable.references.map((ref) => ({ ref, name: variable.name })),
+						),
+					...globalScope.through
+						.filter((ref) => restrictedGlobals.includes(ref.identifier.name))
+						.map((ref) => ({ ref, name: ref.identifier.name })),
+				];
+
+				allReferences.forEach(({ ref, name }) => checkReference(ref, name));
+			},
+		};
+	},
+});

package/src/rules/no-restricted-imports.test.ts

@@ -0,0 +1,181 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { NoRestrictedImportsRule } from './no-restricted-imports.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-restricted-imports', NoRestrictedImportsRule, {
+	valid: [
+		{
+			code: 'import { WorkflowExecuteMode } from "n8n-workflow";',
+		},
+		{
+			code: 'import _ from "lodash";',
+		},
+		{
+			code: 'import moment from "moment";',
+		},
+		{
+			code: 'import pLimit from "p-limit";',
+		},
+		{
+			code: 'import { DateTime } from "luxon";',
+		},
+		{
+			code: 'import { z } from "zod";',
+		},
+		{
+			code: 'import crypto from "crypto";',
+		},
+		{
+			code: 'import crypto from "node:crypto";',
+		},
+		{
+			code: 'import { helper } from "./helper";',
+		},
+		{
+			code: 'import { utils } from "../utils";',
+		},
+		{
+			code: 'const helper = require("./helper");',
+		},
+		{
+			code: 'const utils = require("../utils");',
+		},
+		{
+			code: 'const _ = require("lodash");',
+		},
+		{
+			code: 'require.resolve("lodash");',
+		},
+		{
+			code: 'require.resolve("./helper");',
+		},
+		{
+			code: 'require.resolve("../utils");',
+		},
+		{
+			code: 'const workflow = await import("n8n-workflow");',
+		},
+		{
+			code: 'import("lodash").then((_) => {});',
+		},
+		{
+			code: 'const helper = await import("./helper");',
+		},
+		{
+			code: 'import("../utils").then((utils) => {});',
+		},
+		{
+			code: 'import(`lodash`).then((_) => {});',
+		},
+		{
+			code: 'require(`./helper`);',
+		},
+		{
+			code: 'require.resolve(`n8n-workflow`);',
+		},
+		{
+			code: 'const workflow = await import(`n8n-workflow`);',
+		},
+	],
+	invalid: [
+		{
+			code: 'import fs from "fs";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'import path from "path";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'import express from "express";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'import axios from "axios";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'axios' } }],
+		},
+		{
+			code: 'import { Client } from "@elastic/elasticsearch";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: '@elastic/elasticsearch' } }],
+		},
+		{
+			code: 'const fs = require("fs");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'const path = require("path");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'const express = require("express");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'require.resolve("fs");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'require.resolve("express");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'const resolved = require.resolve("axios");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'axios' } }],
+		},
+		{
+			code: `
+import fs from "fs";
+import path from "path";
+import { WorkflowExecuteMode } from "n8n-workflow";`,
+			errors: [
+				{ messageId: 'restrictedImport', data: { modulePath: 'fs' } },
+				{ messageId: 'restrictedImport', data: { modulePath: 'path' } },
+			],
+		},
+		{
+			code: `
+const fs = require("fs");
+const express = require("express");
+const lodash = require("lodash");`,
+			errors: [
+				{ messageId: 'restrictedRequire', data: { modulePath: 'fs' } },
+				{ messageId: 'restrictedRequire', data: { modulePath: 'express' } },
+			],
+		},
+		{
+			code: 'const fs = await import("fs");',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'import("path").then((path) => {});',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'const express = await import("express");',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'const path = require(`path`);',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'require.resolve(`express`);',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'const axios = await import(`axios`);',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'axios' } }],
+		},
+		{
+			code: `
+const fs = await import("fs");
+import("axios").then((axios) => {});
+const workflow = await import("n8n-workflow");`,
+			errors: [
+				{ messageId: 'restrictedDynamicImport', data: { modulePath: 'fs' } },
+				{ messageId: 'restrictedDynamicImport', data: { modulePath: 'axios' } },
+			],
+		},
+	],
+});