@n8n/eslint-plugin-community-nodes 0.8.0 → 0.10.0

package/src/rules/no-http-request-with-manual-auth.ts

@@ -0,0 +1,78 @@
+/**
+ * Flags `this.helpers.httpRequest()` in functions that also call `this.getCredentials()`.
+ * Those functions should use `this.helpers.httpRequestWithAuthentication()` instead.
+ *
+ * Uses a function-scope stack: if both `getCredentials` and `httpRequest` appear in
+ * the same function body, every `httpRequest` call is reported. Nested functions are
+ * checked independently.
+ *
+ * Alternatives considered:
+ * - Checking for credential variables in `httpRequest` arguments — misses the common
+ *   pattern where options are built in a separate variable first.
+ * - Matching auth header names (`Authorization`, etc.) — brittle and requires deep
+ *   AST traversal with no guarantee of coverage.
+ *
+ * Known false positive: a function that fetches credentials for a non-HTTP purpose
+ * and also makes an unauthenticated request. Use eslint-disable to suppress.
+ */
+
+import type { TSESTree } from '@typescript-eslint/utils';
+
+import { createRule, isThisHelpersMethodCall, isThisMethodCall } from '../utils/index.js';
+
+type FunctionScope = {
+	getCredentialsCall: TSESTree.CallExpression | null;
+	httpRequestCalls: TSESTree.CallExpression[];
+};
+
+export const NoHttpRequestWithManualAuthRule = createRule({
+	name: 'no-http-request-with-manual-auth',
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description:
+				'Disallow this.helpers.httpRequest() in functions that call this.getCredentials(). Use this.helpers.httpRequestWithAuthentication() instead.',
+		},
+		messages: {
+			useHttpRequestWithAuthentication:
+				"Avoid calling 'this.helpers.httpRequest()' in a function that retrieves credentials via 'this.getCredentials()'. Use 'this.helpers.httpRequestWithAuthentication()' instead — it handles authentication internally and benefits from future n8n improvements like token refresh and audit logging.",
+		},
+		schema: [],
+		hasSuggestions: false,
+	},
+	defaultOptions: [],
+	create(context) {
+		const scopeStack: FunctionScope[] = [];
+
+		const pushScope = () => scopeStack.push({ getCredentialsCall: null, httpRequestCalls: [] });
+
+		const popScope = () => {
+			const scope = scopeStack.pop();
+			if (scope?.getCredentialsCall && scope.httpRequestCalls.length > 0) {
+				for (const call of scope.httpRequestCalls) {
+					context.report({ node: call, messageId: 'useHttpRequestWithAuthentication' });
+				}
+			}
+		};
+
+		return {
+			FunctionDeclaration: pushScope,
+			FunctionExpression: pushScope,
+			ArrowFunctionExpression: pushScope,
+			'FunctionDeclaration:exit': popScope,
+			'FunctionExpression:exit': popScope,
+			'ArrowFunctionExpression:exit': popScope,
+
+			CallExpression(node: TSESTree.CallExpression) {
+				const scope = scopeStack[scopeStack.length - 1];
+				if (!scope) return;
+				if (isThisMethodCall(node, 'getCredentials')) {
+					scope.getCredentialsCall = node;
+				}
+				if (isThisHelpersMethodCall(node, 'httpRequest')) {
+					scope.httpRequestCalls.push(node);
+				}
+			},
+		};
+	},
+});

package/src/rules/node-class-description-icon-missing.test.ts

@@ -0,0 +1,113 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { NodeClassDescriptionIconMissingRule } from './node-class-description-icon-missing.js';
+
+const ruleTester = new RuleTester();
+
+const nodeFilePath = '/tmp/TestNode.node.ts';
+const nonNodeFilePath = '/tmp/SomeHelper.ts';
+
+function createNodeCode(withIcon: boolean): string {
+	const iconLine = withIcon ? "\n\t\ticon: 'file:testNode.svg'," : '';
+	return `
+import type { INodeType } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['transform'],
+		version: 1,
+		description: 'Test',${iconLine}
+		inputs: ['main'],
+		outputs: ['main'],
+		properties: [],
+	};
+}`;
+}
+
+function createNodeCodeWithLightDarkIcon(): string {
+	return `
+import type { INodeType } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['transform'],
+		version: 1,
+		description: 'Test',
+		icon: { light: 'file:testNode.svg', dark: 'file:testNode.dark.svg' },
+		inputs: ['main'],
+		outputs: ['main'],
+		properties: [],
+	};
+}`;
+}
+
+function createRegularClass(): string {
+	return `
+export class RegularClass {
+	description = {
+		displayName: 'Test',
+	};
+}`;
+}
+
+ruleTester.run('node-class-description-icon-missing', NodeClassDescriptionIconMissingRule, {
+	valid: [
+		{
+			name: 'node with icon defined',
+			filename: nodeFilePath,
+			code: createNodeCode(true),
+		},
+		{
+			name: 'node with light/dark icon object',
+			filename: nodeFilePath,
+			code: createNodeCodeWithLightDarkIcon(),
+		},
+		{
+			name: 'class not implementing INodeType is ignored',
+			filename: nodeFilePath,
+			code: createRegularClass(),
+		},
+		{
+			name: 'non-.node.ts file is ignored',
+			filename: nonNodeFilePath,
+			code: createNodeCode(false),
+		},
+	],
+	invalid: [
+		{
+			name: 'node missing icon property',
+			filename: nodeFilePath,
+			code: createNodeCode(false),
+			errors: [
+				{
+					messageId: 'missingIcon',
+					suggestions: [
+						{
+							messageId: 'addPlaceholder',
+							output: `
+import type { INodeType } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['transform'],
+		version: 1,
+		description: 'Test',
+		inputs: ['main'],
+		outputs: ['main'],
+		properties: [],
+		icon: "file:./icon.svg",
+	};
+}`,
+						},
+					],
+				},
+			],
+		},
+	],
+});

package/src/rules/node-class-description-icon-missing.ts

@@ -0,0 +1,71 @@
+import { TSESTree } from '@typescript-eslint/utils';
+
+import {
+	isNodeTypeClass,
+	findClassProperty,
+	findObjectProperty,
+	isFileType,
+	createRule,
+} from '../utils/index.js';
+
+export const NodeClassDescriptionIconMissingRule = createRule({
+	name: 'node-class-description-icon-missing',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Node class description must have an `icon` property defined',
+		},
+		messages: {
+			missingIcon: 'Node class description is missing required `icon` property',
+			addPlaceholder: 'Add icon property with placeholder',
+		},
+		schema: [],
+		hasSuggestions: true,
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!isFileType(context.filename, '.node.ts')) {
+			return {};
+		}
+
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) {
+					return;
+				}
+
+				const descriptionProperty = findClassProperty(node, 'description');
+				if (
+					!descriptionProperty?.value ||
+					descriptionProperty.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression
+				) {
+					return;
+				}
+
+				const descriptionValue = descriptionProperty.value;
+				const iconProperty = findObjectProperty(descriptionValue, 'icon');
+				if (iconProperty) {
+					return;
+				}
+
+				context.report({
+					node,
+					messageId: 'missingIcon',
+					suggest: [
+						{
+							messageId: 'addPlaceholder',
+							fix(fixer) {
+								const lastProperty =
+									descriptionValue.properties[descriptionValue.properties.length - 1];
+								if (lastProperty) {
+									return fixer.insertTextAfter(lastProperty, ',\n\t\ticon: "file:./icon.svg"');
+								}
+								return null;
+							},
+						},
+					],
+				});
+			},
+		};
+	},
+});

package/src/utils/ast-utils.ts

@@ -197,6 +197,36 @@ export function extractCredentialNameFromArray(
 	return info ? { name: info.name, node: info.node } : null;
 }
 
+/** Matches the `this.helpers` MemberExpression (the object part of `this.helpers.foo`). */
+export function isThisHelpersAccess(node: TSESTree.MemberExpression): boolean {
+	return (
+		node.object?.type === AST_NODE_TYPES.MemberExpression &&
+		node.object.object?.type === AST_NODE_TYPES.ThisExpression &&
+		node.object.property?.type === AST_NODE_TYPES.Identifier &&
+		node.object.property.name === 'helpers'
+	);
+}
+
+/** Matches a call expression of the form `this.methodName(...)`. */
+export function isThisMethodCall(node: TSESTree.CallExpression, method: string): boolean {
+	return (
+		node.callee.type === AST_NODE_TYPES.MemberExpression &&
+		node.callee.object.type === AST_NODE_TYPES.ThisExpression &&
+		node.callee.property.type === AST_NODE_TYPES.Identifier &&
+		node.callee.property.name === method
+	);
+}
+
+/** Matches a call expression of the form `this.helpers.methodName(...)`. */
+export function isThisHelpersMethodCall(node: TSESTree.CallExpression, method: string): boolean {
+	return (
+		node.callee.type === AST_NODE_TYPES.MemberExpression &&
+		node.callee.property.type === AST_NODE_TYPES.Identifier &&
+		node.callee.property.name === method &&
+		isThisHelpersAccess(node.callee)
+	);
+}
+
 export function findSimilarStrings(
 	target: string,
 	candidates: Set<string>,