@n8n/eslint-plugin-community-nodes 0.3.0 → 0.5.0

package/src/rules/credential-test-required.test.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { CredentialTestRequiredRule } from './credential-test-required.js';
 
 const ruleTester = new RuleTester();
@@ -20,13 +21,13 @@ function createCredentialCode(options: {
 	} = options;
 
 	const imports = hasTest
-		? `import type { ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';`
-		: `import type { ICredentialType, INodeProperties } from 'n8n-workflow';`;
+		? "import type { ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';"
+		: "import type { ICredentialType, INodeProperties } from 'n8n-workflow';";
 
 	const extendsStr = extendsArray ? `\n\textends = ${JSON.stringify(extendsArray)};` : '';
 
 	const testProperty = hasTest
-		? `\n\n\ttest: ICredentialTestRequest = {\n\t\trequest: {\n\t\t\tbaseURL: 'https://api.example.com',\n\t\t\turl: '/test',\n\t\t},\n\t};`
+		? "\n\n\ttest: ICredentialTestRequest = {\n\t\trequest: {\n\t\t\tbaseURL: 'https://api.example.com',\n\t\t\turl: '/test',\n\t\t},\n\t};"
 		: '';
 
 	return `
@@ -46,57 +47,6 @@ export class ${className} {
 }`;
 }
 
-function createNodeCode(options: {
-	name?: string;
-	displayName?: string;
-	credentials?: Array<string | { name: string; testedBy?: string }>;
-	extendsClass?: string;
-}): string {
-	const { name = 'myNode', displayName = 'My Node', credentials = [], extendsClass } = options;
-
-	const credentialsArray = credentials
-		.map((cred) => {
-			if (typeof cred === 'string') {
-				return `'${cred}'`;
-			}
-			const testedByStr = cred.testedBy ? `, testedBy: '${cred.testedBy}'` : '';
-			return `{ name: '${cred.name}'${testedByStr} }`;
-		})
-		.join(', ');
-
-	const classDeclaration = extendsClass
-		? `export class ${name.charAt(0).toUpperCase() + name.slice(1)} extends ${extendsClass}`
-		: `export class ${name.charAt(0).toUpperCase() + name.slice(1)} implements INodeType`;
-
-	const descriptionProperty = extendsClass
-		? `description = {` // Extending classes might not need full INodeTypeDescription
-		: `description: INodeTypeDescription = {`;
-
-	return `
-import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
-
-${classDeclaration} {
-	${descriptionProperty}
-		displayName: '${displayName}',
-		name: '${name}',
-		group: ['transform'],
-		version: 1,
-		description: 'A test node',
-		defaults: {
-			name: '${displayName}',
-		},
-		inputs: ['main'],
-		outputs: ['main'],
-		credentials: [${credentialsArray}],
-		properties: [],
-	};
-
-	execute() {
-		return Promise.resolve([]);
-	}
-}`;
-}
-
 ruleTester.run('credential-test-required', CredentialTestRequiredRule, {
 	valid: [
 		{
@@ -129,19 +79,96 @@ ruleTester.run('credential-test-required', CredentialTestRequiredRule, {
 			name: 'credential class missing test property and no testedBy in package',
 			filename: 'MyApi.credentials.ts',
 			code: createCredentialCode({}),
-			errors: [{ messageId: 'missingCredentialTest', data: { className: 'MyApi' } }],
+			errors: [
+				{
+					messageId: 'missingCredentialTest',
+					data: { className: 'MyApi' },
+					suggestions: [
+						{
+							messageId: 'addTemplate',
+							output: `
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class MyApi implements ICredentialType {
+	name = 'myApi';
+	displayName = 'My API';
+	properties: INodeProperties[] = [];
+
+	test: ICredentialTestRequest = {
+		request: {
+			method: 'GET',
+			url: '={{$credentials.server}}/test', // Replace with actual endpoint
+		},
+	};
+}`,
+						},
+					],
+				},
+			],
 		},
 		{
 			name: 'credential class with extends but not oAuth2Api and no testedBy in package',
 			filename: 'MyApi.credentials.ts',
 			code: createCredentialCode({ extends: ['someOtherApi'] }),
-			errors: [{ messageId: 'missingCredentialTest', data: { className: 'MyApi' } }],
+			errors: [
+				{
+					messageId: 'missingCredentialTest',
+					data: { className: 'MyApi' },
+					suggestions: [
+						{
+							messageId: 'addTemplate',
+							output: `
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class MyApi implements ICredentialType {
+	name = 'myApi';
+	extends = ["someOtherApi"];
+	displayName = 'My API';
+	properties: INodeProperties[] = [];
+
+	test: ICredentialTestRequest = {
+		request: {
+			method: 'GET',
+			url: '={{$credentials.server}}/test', // Replace with actual endpoint
+		},
+	};
+}`,
+						},
+					],
+				},
+			],
 		},
 		{
 			name: 'credential class with empty extends array and no testedBy in package',
 			filename: 'MyApi.credentials.ts',
 			code: createCredentialCode({ extends: [] }),
-			errors: [{ messageId: 'missingCredentialTest', data: { className: 'MyApi' } }],
+			errors: [
+				{
+					messageId: 'missingCredentialTest',
+					data: { className: 'MyApi' },
+					suggestions: [
+						{
+							messageId: 'addTemplate',
+							output: `
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class MyApi implements ICredentialType {
+	name = 'myApi';
+	extends = [];
+	displayName = 'My API';
+	properties: INodeProperties[] = [];
+
+	test: ICredentialTestRequest = {
+		request: {
+			method: 'GET',
+			url: '={{$credentials.server}}/test', // Replace with actual endpoint
+		},
+	};
+}`,
+						},
+					],
+				},
+			],
 		},
 	],
 });

package/src/rules/credential-test-required.ts

@@ -1,4 +1,6 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+import type { ReportSuggestionArray } from '@typescript-eslint/utils/ts-eslint';
+import { dirname } from 'node:path';
+
 import {
 	isCredentialTypeClass,
 	findClassProperty,
@@ -7,20 +9,23 @@ import {
 	getStringLiteralValue,
 	findPackageJson,
 	areAllCredentialUsagesTestedByNodes,
+	createRule,
 } from '../utils/index.js';
-import { dirname } from 'node:path';
 
-export const CredentialTestRequiredRule = ESLintUtils.RuleCreator.withoutDocs({
+export const CredentialTestRequiredRule = createRule({
+	name: 'credential-test-required',
 	meta: {
 		type: 'problem',
 		docs: {
 			description: 'Ensure credentials have a credential test',
 		},
 		messages: {
+			addTemplate: 'Add basic credential test template',
 			missingCredentialTest:
 				'Credential class "{{ className }}" must have a test property or be tested by a node via testedBy',
 		},
 		schema: [],
+		hasSuggestions: true,
 	},
 	defaultOptions: [],
 	create(context) {
@@ -73,27 +78,68 @@ export const CredentialTestRequiredRule = ESLintUtils.RuleCreator.withoutDocs({
 
 				const pkgDir = getPackageDir();
 				if (!pkgDir) {
+					const suggestions: ReportSuggestionArray<'addTemplate' | 'missingCredentialTest'> = [];
+
+					const testProperty = createCredentialTestTemplate();
+					suggestions.push({
+						messageId: 'addTemplate',
+						fix(fixer) {
+							const classBody = node.body.body;
+							const lastProperty = classBody[classBody.length - 1];
+							if (lastProperty) {
+								return fixer.insertTextAfter(lastProperty, `\n\n${testProperty}`);
+							}
+							return null;
+						},
+					});
+
 					context.report({
 						node,
 						messageId: 'missingCredentialTest',
 						data: {
-							className: node.id?.name || 'Unknown',
+							className: node.id?.name ?? 'Unknown',
 						},
+						suggest: suggestions,
 					});
 					return;
 				}
 
 				const allUsagesTestedByNodes = areAllCredentialUsagesTestedByNodes(credentialName, pkgDir);
 				if (!allUsagesTestedByNodes) {
+					const suggestions: ReportSuggestionArray<'addTemplate' | 'missingCredentialTest'> = [];
+
+					const testProperty = createCredentialTestTemplate();
+					suggestions.push({
+						messageId: 'addTemplate',
+						fix(fixer) {
+							const classBody = node.body.body;
+							const lastProperty = classBody[classBody.length - 1];
+							if (lastProperty) {
+								return fixer.insertTextAfter(lastProperty, `\n\n${testProperty}`);
+							}
+							return null;
+						},
+					});
+
 					context.report({
 						node,
 						messageId: 'missingCredentialTest',
 						data: {
-							className: node.id?.name || 'Unknown',
+							className: node.id?.name ?? 'Unknown',
 						},
+						suggest: suggestions,
 					});
 				}
 			},
 		};
 	},
 });
+
+function createCredentialTestTemplate(): string {
+	return `\ttest: ICredentialTestRequest = {
+\t\trequest: {
+\t\t\tmethod: 'GET',
+\t\t\turl: '={{$credentials.server}}/test', // Replace with actual endpoint
+\t\t},
+\t};`;
+}

package/src/rules/icon-validation.test.ts

@@ -1,26 +1,51 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import { IconValidationRule } from './icon-validation.js';
-import { vi } from 'vitest';
 import * as fs from 'node:fs';
+import { vi } from 'vitest';
+
+import { IconValidationRule } from './icon-validation.js';
 
 const ruleTester = new RuleTester();
 
 vi.mock('node:fs', () => ({
 	existsSync: vi.fn(),
+	readdirSync: vi.fn(),
 }));
 
 const mockExistsSync = vi.mocked(fs.existsSync);
+const mockReaddirSync = vi.mocked(fs.readdirSync);
+
+const mockSvgFiles = [
+	'TestNode.svg',
+	'ValidIcon.svg',
+	'ValidIcon.dark.svg',
+	'SameIcon.svg',
+	'github.svg',
+];
 
 function setupMockFileSystem() {
 	mockExistsSync.mockImplementation((path: fs.PathLike) => {
 		const pathStr = path.toString();
-		return (
-			pathStr.includes('TestNode.svg') ||
-			pathStr.includes('ValidIcon.svg') ||
-			pathStr.includes('ValidIcon.dark.svg') ||
-			pathStr.includes('SameIcon.svg') ||
-			pathStr.includes('NotSvg.png')
-		);
+
+		if (mockSvgFiles.some((file) => pathStr.includes(file)) || pathStr.includes('NotSvg.png')) {
+			return true;
+		}
+
+		if (pathStr.endsWith('/tmp/icons') || pathStr.endsWith('/tmp') || pathStr.endsWith('icons')) {
+			return true;
+		}
+
+		return false;
+	});
+
+	// @ts-expect-error Typescript does not select the correct overload
+	mockReaddirSync.mockImplementation((path: fs.PathLike): string[] => {
+		const pathStr = path.toString();
+
+		if (pathStr.includes('icons')) {
+			return [...mockSvgFiles, 'NotSvg.png'];
+		}
+
+		return [];
 	});
 }
 
@@ -34,10 +59,10 @@ function createNodeCode(
 	includeTypeImport: boolean = false,
 ): string {
 	const typeImport = includeTypeImport
-		? `import type { INodeType, INodeTypeDescription } from 'n8n-workflow';`
-		: `import type { INodeType } from 'n8n-workflow';`;
+		? "import type { INodeType, INodeTypeDescription } from 'n8n-workflow';"
+		: "import type { INodeType } from 'n8n-workflow';";
 
-	const typeAnnotation = includeTypeImport ? `: INodeTypeDescription` : '';
+	const typeAnnotation = includeTypeImport ? ': INodeTypeDescription' : '';
 
 	let iconProperty = '';
 	if (icon) {
@@ -151,7 +176,18 @@ ruleTester.run('icon-validation', IconValidationRule, {
 			name: 'node missing icon property in description',
 			filename: nodeFilePath,
 			code: createNodeCode(undefined, true),
-			errors: [{ messageId: 'missingIcon' }],
+			errors: [
+				{
+					messageId: 'missingIcon',
+					suggestions: [
+						{
+							messageId: 'addPlaceholder',
+							output:
+								"\nimport type { INodeType, INodeTypeDescription } from 'n8n-workflow';\n\nexport class TestNode implements INodeType {\n\tdescription: INodeTypeDescription = {\n\t\tdisplayName: 'Test Node',\n\t\tname: 'testNode',\n\t\t\n\t\tgroup: ['input'],\n\t\tversion: 1,\n\t\tdescription: 'A test node',\n\t\tdefaults: {\n\t\t\tname: 'Test Node',\n\t\t},\n\t\tinputs: ['main'],\n\t\toutputs: ['main'],\n\t\tproperties: [],\n\t\ticon: \"file:./icon.svg\",\n\t};\n}",
+						},
+					],
+				},
+			],
 		},
 		{
 			name: 'icon file does not exist in description',
@@ -175,7 +211,18 @@ ruleTester.run('icon-validation', IconValidationRule, {
 			name: 'credential missing icon property',
 			filename: credentialFilePath,
 			code: createCredentialCode(),
-			errors: [{ messageId: 'missingIcon' }],
+			errors: [
+				{
+					messageId: 'missingIcon',
+					suggestions: [
+						{
+							messageId: 'addPlaceholder',
+							output:
+								"\nimport type { ICredentialType, INodeProperties } from 'n8n-workflow';\n\nexport class TestCredential implements ICredentialType {\n\tname = 'testApi';\n\tdisplayName = 'Test API';\n\t\n\tproperties: INodeProperties[] = [];\n\n\ticon = \"file:./icon.svg\";\n}",
+						},
+					],
+				},
+			],
 		},
 		{
 			name: 'credential icon file does not exist',
@@ -192,5 +239,41 @@ ruleTester.run('icon-validation', IconValidationRule, {
 			}),
 			errors: [{ messageId: 'lightDarkSame', data: { iconPath: 'icons/SameIcon.svg' } }],
 		},
+		{
+			name: 'node icon file does not exist but similar file exists - should suggest similar file',
+			filename: nodeFilePath,
+			code: createNodeCode('file:icons/github2.svg'),
+			errors: [
+				{
+					messageId: 'iconFileNotFound',
+					data: { iconPath: 'icons/github2.svg' },
+					suggestions: [
+						{
+							messageId: 'similarIcon',
+							data: { suggestedName: 'icons/github.svg' },
+							output: `
+import type { INodeType } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		icon: "file:icons/github.svg",
+		group: ['input'],
+		version: 1,
+		description: 'A test node',
+		defaults: {
+			name: 'Test Node',
+		},
+		inputs: ['main'],
+		outputs: ['main'],
+		properties: [],
+	};
+}`,
+						},
+					],
+				},
+			],
+		},
 	],
 });

package/src/rules/icon-validation.ts

@@ -1,5 +1,7 @@
-import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import { TSESTree } from '@typescript-eslint/utils';
+import type { ReportSuggestionArray } from '@typescript-eslint/utils/ts-eslint';
 import { dirname } from 'node:path';
+
 import {
 	isNodeTypeClass,
 	isCredentialTypeClass,
@@ -7,24 +9,34 @@ import {
 	findObjectProperty,
 	getStringLiteralValue,
 	validateIconPath,
+	findSimilarSvgFiles,
 	isFileType,
+	createRule,
 } from '../utils/index.js';
 
-export const IconValidationRule = ESLintUtils.RuleCreator.withoutDocs({
+const messages = {
+	iconFileNotFound: 'Icon file "{{ iconPath }}" does not exist',
+	iconNotSvg: 'Icon file "{{ iconPath }}" must be an SVG file (end with .svg)',
+	lightDarkSame: 'Light and dark icons cannot be the same file. Both point to "{{ iconPath }}"',
+	invalidIconPath: 'Icon path "{{ iconPath }}" must use file: protocol and be a string',
+	missingIcon: 'Node/Credential class must have an icon property defined',
+	addPlaceholder: 'Add icon property with placeholder',
+	addFileProtocol: "Add 'file:' protocol to icon path",
+	changeExtension: "Change icon extension to '.svg'",
+	similarIcon: "Use existing icon '{{ suggestedName }}'",
+} as const;
+
+export const IconValidationRule = createRule({
+	name: 'icon-validation',
 	meta: {
 		type: 'problem',
 		docs: {
 			description:
 				'Validate node and credential icon files exist, are SVG format, and light/dark icons are different',
 		},
-		messages: {
-			iconFileNotFound: 'Icon file "{{ iconPath }}" does not exist',
-			iconNotSvg: 'Icon file "{{ iconPath }}" must be an SVG file (end with .svg)',
-			lightDarkSame: 'Light and dark icons cannot be the same file. Both point to "{{ iconPath }}"',
-			invalidIconPath: 'Icon path "{{ iconPath }}" must use file: protocol and be a string',
-			missingIcon: 'Node/Credential class must have an icon property defined',
-		},
+		messages,
 		schema: [],
+		hasSuggestions: true,
 	},
 	defaultOptions: [],
 	create(context) {
@@ -40,7 +52,7 @@ export const IconValidationRule = ESLintUtils.RuleCreator.withoutDocs({
 				context.report({
 					node,
 					messageId: 'invalidIconPath',
-					data: { iconPath: iconPath || '' },
+					data: { iconPath: iconPath ?? '' },
 				});
 				return false;
 			}
@@ -49,30 +61,68 @@ export const IconValidationRule = ESLintUtils.RuleCreator.withoutDocs({
 			const validation = validateIconPath(iconPath, currentDir);
 
 			if (!validation.isFile) {
+				const suggestions: ReportSuggestionArray<keyof typeof messages> = [];
+				if (!iconPath.startsWith('file:')) {
+					suggestions.push({
+						messageId: 'addFileProtocol',
+						fix(fixer) {
+							return fixer.replaceText(node, `"file:${iconPath}"`);
+						},
+					});
+				}
+
 				context.report({
 					node,
 					messageId: 'invalidIconPath',
 					data: { iconPath },
+					suggest: suggestions,
 				});
 				return false;
 			}
 
 			if (!validation.isSvg) {
 				const relativePath = iconPath.replace(/^file:/, '');
+				const suggestions: ReportSuggestionArray<keyof typeof messages> = [];
+
+				const pathWithoutExt = relativePath.replace(/\.[^/.]+$/, '');
+				const svgPath = `${pathWithoutExt}.svg`;
+				suggestions.push({
+					messageId: 'changeExtension',
+					fix(fixer) {
+						return fixer.replaceText(node, `"file:${svgPath}"`);
+					},
+				});
+
 				context.report({
 					node,
 					messageId: 'iconNotSvg',
 					data: { iconPath: relativePath },
+					suggest: suggestions,
 				});
 				return false;
 			}
 
 			if (!validation.exists) {
 				const relativePath = iconPath.replace(/^file:/, '');
+				const suggestions: ReportSuggestionArray<keyof typeof messages> = [];
+
+				// Find similar SVG files in the same directory
+				const similarFiles = findSimilarSvgFiles(relativePath, currentDir);
+				for (const similarFile of similarFiles) {
+					suggestions.push({
+						messageId: 'similarIcon',
+						data: { suggestedName: similarFile },
+						fix(fixer) {
+							return fixer.replaceText(node, `"file:${similarFile}"`);
+						},
+					});
+				}
+
 				context.report({
 					node,
 					messageId: 'iconFileNotFound',
 					data: { iconPath: relativePath },
+					suggest: suggestions,
 				});
 				return false;
 			}
@@ -81,10 +131,10 @@ export const IconValidationRule = ESLintUtils.RuleCreator.withoutDocs({
 		};
 
 		const validateIconValue = (iconValue: TSESTree.Node) => {
-			if (iconValue.type === 'Literal') {
+			if (iconValue.type === TSESTree.AST_NODE_TYPES.Literal) {
 				const iconPath = getStringLiteralValue(iconValue);
 				validateIcon(iconPath, iconValue);
-			} else if (iconValue.type === 'ObjectExpression') {
+			} else if (iconValue.type === TSESTree.AST_NODE_TYPES.ObjectExpression) {
 				const lightProperty = findObjectProperty(iconValue, 'light');
 				const darkProperty = findObjectProperty(iconValue, 'dark');
 
@@ -121,7 +171,7 @@ export const IconValidationRule = ESLintUtils.RuleCreator.withoutDocs({
 					const descriptionProperty = findClassProperty(node, 'description');
 					if (
 						!descriptionProperty?.value ||
-						descriptionProperty.value.type !== 'ObjectExpression'
+						descriptionProperty.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression
 					) {
 						context.report({
 							node,
@@ -130,11 +180,27 @@ export const IconValidationRule = ESLintUtils.RuleCreator.withoutDocs({
 						return;
 					}
 
-					const iconProperty = findObjectProperty(descriptionProperty.value, 'icon');
+					const descriptionValue = descriptionProperty.value;
+					const iconProperty = findObjectProperty(descriptionValue, 'icon');
 					if (!iconProperty) {
+						const suggestions: ReportSuggestionArray<keyof typeof messages> = [];
+
+						suggestions.push({
+							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;
+							},
+						});
+
 						context.report({
 							node,
 							messageId: 'missingIcon',
+							suggest: suggestions,
 						});
 						return;
 					}
@@ -143,9 +209,24 @@ export const IconValidationRule = ESLintUtils.RuleCreator.withoutDocs({
 				} else if (isCredentialClass) {
 					const iconProperty = findClassProperty(node, 'icon');
 					if (!iconProperty?.value) {
+						const suggestions: ReportSuggestionArray<keyof typeof messages> = [];
+
+						suggestions.push({
+							messageId: 'addPlaceholder',
+							fix(fixer) {
+								const classBody = node.body.body;
+								const lastProperty = classBody[classBody.length - 1];
+								if (lastProperty) {
+									return fixer.insertTextAfter(lastProperty, '\n\n\ticon = "file:./icon.svg";');
+								}
+								return null;
+							},
+						});
+
 						context.report({
 							node,
 							messageId: 'missingIcon',
+							suggest: suggestions,
 						});
 						return;
 					}

package/src/rules/index.ts

@@ -1,13 +1,15 @@
 import type { AnyRuleModule } from '@typescript-eslint/utils/ts-eslint';
-import { NoRestrictedGlobalsRule } from './no-restricted-globals.js';
-import { NoRestrictedImportsRule } from './no-restricted-imports.js';
+
+import { CredentialDocumentationUrlRule } from './credential-documentation-url.js';
 import { CredentialPasswordFieldRule } from './credential-password-field.js';
+import { CredentialTestRequiredRule } from './credential-test-required.js';
+import { IconValidationRule } from './icon-validation.js';
+import { NoCredentialReuseRule } from './no-credential-reuse.js';
 import { NoDeprecatedWorkflowFunctionsRule } from './no-deprecated-workflow-functions.js';
+import { NoRestrictedGlobalsRule } from './no-restricted-globals.js';
+import { NoRestrictedImportsRule } from './no-restricted-imports.js';
 import { NodeUsableAsToolRule } from './node-usable-as-tool.js';
 import { PackageNameConventionRule } from './package-name-convention.js';
-import { CredentialTestRequiredRule } from './credential-test-required.js';
-import { NoCredentialReuseRule } from './no-credential-reuse.js';
-import { IconValidationRule } from './icon-validation.js';
 import { ResourceOperationPatternRule } from './resource-operation-pattern.js';
 
 export const rules = {
@@ -21,4 +23,5 @@ export const rules = {
 	'no-credential-reuse': NoCredentialReuseRule,
 	'icon-validation': IconValidationRule,
 	'resource-operation-pattern': ResourceOperationPatternRule,
+	'credential-documentation-url': CredentialDocumentationUrlRule,
 } satisfies Record<string, AnyRuleModule>;