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

package/src/rules/no-credential-reuse.test.ts

@@ -1,35 +1,27 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import { NoCredentialReuseRule } from './no-credential-reuse.js';
 import { vi } from 'vitest';
-import * as fs from 'node:fs';
 
-const ruleTester = new RuleTester();
+import { NoCredentialReuseRule } from './no-credential-reuse.js';
+import * as fileUtils from '../utils/file-utils.js';
+
+vi.mock('../utils/file-utils.js', async () => {
+	const actual = await vi.importActual('../utils/file-utils.js');
+	return {
+		...actual,
+		readPackageJsonCredentials: vi.fn(),
+		findPackageJson: vi.fn(),
+	};
+});
 
-// Mock fs functions
-vi.mock('node:fs', () => ({
-	readFileSync: vi.fn(),
-	existsSync: vi.fn(),
-}));
+const mockReadPackageJsonCredentials = vi.mocked(fileUtils.readPackageJsonCredentials);
+const mockFindPackageJson = vi.mocked(fileUtils.findPackageJson);
 
-const mockReadFileSync = vi.mocked(fs.readFileSync);
-const mockExistsSync = vi.mocked(fs.existsSync);
+const ruleTester = new RuleTester();
 
 const nodeFilePath = '/tmp/TestNode.node.ts';
 
-function createCredentialClass(name: string, displayName: string): string {
-	return `
-		import type { ICredentialType, INodeProperties } from 'n8n-workflow';
-
-		export class ${name.charAt(0).toUpperCase() + name.slice(1)} implements ICredentialType {
-			name = '${name}';
-			displayName = '${displayName}';
-			properties: INodeProperties[] = [];
-		}
-	`;
-}
-
 function createNodeCode(
-	credentials: (string | { name: string; required?: boolean })[] = [],
+	credentials: Array<string | { name: string; required?: boolean }> = [],
 ): string {
 	const credentialsArray =
 		credentials.length > 0
@@ -66,6 +58,45 @@ export class TestNode implements INodeType {
 }`;
 }
 
+// Helper function to create expected outputs with double quotes (matching rule fix behavior)
+function createExpectedNodeCode(
+	credentials: Array<string | { name: string; required?: boolean }> = [],
+): string {
+	const credentialsArray =
+		credentials.length > 0
+			? credentials
+					.map((cred) => {
+						if (typeof cred === 'string') {
+							return `"${cred}"`;
+						} else {
+							const required =
+								cred.required !== undefined ? `,\n\t\t\t\trequired: ${cred.required}` : '';
+							return `{\n\t\t\t\tname: "${cred.name}"${required},\n\t\t\t}`;
+						}
+					})
+					.join(',\n\t\t\t')
+			: '';
+
+	const credentialsProperty =
+		credentials.length > 0 ? `credentials: [\n\t\t\t${credentialsArray}\n\t\t],` : '';
+
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		${credentialsProperty}
+		properties: [],
+	};
+}`;
+}
+
 // Helper function to create non-node class
 function createNonNodeClass(): string {
 	return `
@@ -90,41 +121,10 @@ export class NotANode {
 }
 
 function setupMockFileSystem() {
-	const packageJson = {
-		name: 'test-package',
-		n8n: {
-			credentials: [
-				'dist/credentials/MyApi.credentials.js',
-				'dist/credentials/AnotherApi.credentials.js',
-			],
-		},
-	};
-
-	const myApiCredential = createCredentialClass('myApiCredential', 'My API');
-	const anotherApiCredential = createCredentialClass('anotherApiCredential', 'Another API');
-
-	mockExistsSync.mockImplementation((path: fs.PathLike) => {
-		const pathStr = path.toString();
-		return (
-			pathStr.includes('package.json') ||
-			pathStr.includes('MyApi.credentials.ts') ||
-			pathStr.includes('AnotherApi.credentials.ts')
-		);
-	});
-
-	mockReadFileSync.mockImplementation((path: any): string => {
-		const pathStr = path.toString();
-		if (pathStr.includes('package.json')) {
-			return JSON.stringify(packageJson, null, 2);
-		}
-		if (pathStr.includes('MyApi.credentials.ts')) {
-			return myApiCredential;
-		}
-		if (pathStr.includes('AnotherApi.credentials.ts')) {
-			return anotherApiCredential;
-		}
-		throw new Error(`File not found: ${pathStr}`);
-	});
+	mockFindPackageJson.mockReturnValue('/tmp/package.json');
+	mockReadPackageJsonCredentials.mockReturnValue(
+		new Set(['myApiCredential', 'anotherApiCredential']),
+	);
 }
 
 setupMockFileSystem();
@@ -171,6 +171,18 @@ ruleTester.run('no-credential-reuse', NoCredentialReuseRule, {
 				{
 					messageId: 'credentialNotInPackage',
 					data: { credentialName: 'ExternalApi' },
+					suggestions: [
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'myApiCredential' },
+							output: createExpectedNodeCode([{ name: 'myApiCredential', required: true }]),
+						},
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'anotherApiCredential' },
+							output: createExpectedNodeCode([{ name: 'anotherApiCredential', required: true }]),
+						},
+					],
 				},
 			],
 		},
@@ -182,6 +194,18 @@ ruleTester.run('no-credential-reuse', NoCredentialReuseRule, {
 				{
 					messageId: 'credentialNotInPackage',
 					data: { credentialName: 'ExternalApi' },
+					suggestions: [
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'myApiCredential' },
+							output: createExpectedNodeCode(['myApiCredential']),
+						},
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'anotherApiCredential' },
+							output: createExpectedNodeCode(['anotherApiCredential']),
+						},
+					],
 				},
 			],
 		},
@@ -197,10 +221,118 @@ ruleTester.run('no-credential-reuse', NoCredentialReuseRule, {
 				{
 					messageId: 'credentialNotInPackage',
 					data: { credentialName: 'ExternalApi' },
+					suggestions: [
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'myApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			'myApiCredential',
+			{
+				name: "myApiCredential",
+				required: true,
+			},
+			'AnotherExternalApi'
+		],
+		properties: [],
+	};
+}`,
+						},
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'anotherApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			'myApiCredential',
+			{
+				name: "anotherApiCredential",
+				required: true,
+			},
+			'AnotherExternalApi'
+		],
+		properties: [],
+	};
+}`,
+						},
+					],
 				},
 				{
 					messageId: 'credentialNotInPackage',
 					data: { credentialName: 'AnotherExternalApi' },
+					suggestions: [
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'myApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			'myApiCredential',
+			{
+				name: 'ExternalApi',
+				required: true,
+			},
+			"myApiCredential"
+		],
+		properties: [],
+	};
+}`,
+						},
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'anotherApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			'myApiCredential',
+			{
+				name: 'ExternalApi',
+				required: true,
+			},
+			"anotherApiCredential"
+		],
+		properties: [],
+	};
+}`,
+						},
+					],
 				},
 			],
 		},
@@ -215,10 +347,126 @@ ruleTester.run('no-credential-reuse', NoCredentialReuseRule, {
 				{
 					messageId: 'credentialNotInPackage',
 					data: { credentialName: 'ExternalApi1' },
+					suggestions: [
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'myApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: "myApiCredential",
+				required: true,
+			},
+			{
+				name: 'ExternalApi2',
+				required: false,
+			}
+		],
+		properties: [],
+	};
+}`,
+						},
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'anotherApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: "anotherApiCredential",
+				required: true,
+			},
+			{
+				name: 'ExternalApi2',
+				required: false,
+			}
+		],
+		properties: [],
+	};
+}`,
+						},
+					],
 				},
 				{
 					messageId: 'credentialNotInPackage',
 					data: { credentialName: 'ExternalApi2' },
+					suggestions: [
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'myApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: 'ExternalApi1',
+				required: true,
+			},
+			{
+				name: "myApiCredential",
+				required: false,
+			}
+		],
+		properties: [],
+	};
+}`,
+						},
+						{
+							messageId: 'useAvailable',
+							data: { suggestedName: 'anotherApiCredential' },
+							output: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: 'ExternalApi1',
+				required: true,
+			},
+			{
+				name: "anotherApiCredential",
+				required: false,
+			}
+		],
+		properties: [],
+	};
+}`,
+						},
+					],
 				},
 			],
 		},

package/src/rules/no-credential-reuse.ts

@@ -1,4 +1,6 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+import { TSESTree } from '@typescript-eslint/types';
+import type { ReportSuggestionArray } from '@typescript-eslint/utils/ts-eslint';
+
 import {
 	isNodeTypeClass,
 	findClassProperty,
@@ -7,9 +9,12 @@ import {
 	findPackageJson,
 	readPackageJsonCredentials,
 	isFileType,
+	findSimilarStrings,
+	createRule,
 } from '../utils/index.js';
 
-export const NoCredentialReuseRule = ESLintUtils.RuleCreator.withoutDocs({
+export const NoCredentialReuseRule = createRule({
+	name: 'no-credential-reuse',
 	meta: {
 		type: 'problem',
 		docs: {
@@ -17,10 +22,13 @@ export const NoCredentialReuseRule = ESLintUtils.RuleCreator.withoutDocs({
 				'Prevent credential re-use security issues by ensuring nodes only reference credentials from the same package',
 		},
 		messages: {
+			didYouMean: "Did you mean '{{ suggestedName }}'?",
+			useAvailable: "Use available credential '{{ suggestedName }}'",
 			credentialNotInPackage:
 				'SECURITY: Node references credential "{{ credentialName }}" which is not defined in this package. This creates a security risk as it attempts to reuse credentials from other packages. Nodes can only use credentials from the same package as listed in package.json n8n.credentials field.',
 		},
 		schema: [],
+		hasSuggestions: true,
 	},
 	defaultOptions: [],
 	create(context) {
@@ -52,7 +60,10 @@ export const NoCredentialReuseRule = ESLintUtils.RuleCreator.withoutDocs({
 				}
 
 				const descriptionProperty = findClassProperty(node, 'description');
-				if (!descriptionProperty?.value || descriptionProperty.value.type !== 'ObjectExpression') {
+				if (
+					!descriptionProperty?.value ||
+					descriptionProperty.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression
+				) {
 					return;
 				}
 
@@ -66,12 +77,41 @@ export const NoCredentialReuseRule = ESLintUtils.RuleCreator.withoutDocs({
 				credentialsArray.elements.forEach((element) => {
 					const credentialInfo = extractCredentialNameFromArray(element);
 					if (credentialInfo && !allowedCredentials.has(credentialInfo.name)) {
+						const similarCredentials = findSimilarStrings(credentialInfo.name, allowedCredentials);
+						const suggestions: ReportSuggestionArray<
+							'didYouMean' | 'useAvailable' | 'credentialNotInPackage'
+						> = [];
+
+						for (const similarName of similarCredentials) {
+							suggestions.push({
+								messageId: 'didYouMean',
+								data: { suggestedName: similarName },
+								fix(fixer) {
+									return fixer.replaceText(credentialInfo.node, `"${similarName}"`);
+								},
+							});
+						}
+
+						if (suggestions.length === 0 && allowedCredentials.size > 0) {
+							const availableCredentials = Array.from(allowedCredentials).slice(0, 3);
+							for (const availableName of availableCredentials) {
+								suggestions.push({
+									messageId: 'useAvailable',
+									data: { suggestedName: availableName },
+									fix(fixer) {
+										return fixer.replaceText(credentialInfo.node, `"${availableName}"`);
+									},
+								});
+							}
+						}
+
 						context.report({
 							node: credentialInfo.node,
 							messageId: 'credentialNotInPackage',
 							data: {
 								credentialName: credentialInfo.name,
 							},
+							suggest: suggestions,
 						});
 					}
 				});

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

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { NoDeprecatedWorkflowFunctionsRule } from './no-deprecated-workflow-functions.js';
 
 const ruleTester = new RuleTester();
@@ -60,6 +61,16 @@ const response3 = await this.helpers.requestOAuth2.call(this, 'google', options)
 				{
 					messageId: 'deprecatedRequestFunction',
 					data: { functionName: 'request', replacement: 'httpRequest' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: { functionName: 'request', replacement: 'httpRequest' },
+							output: `
+const response1 = await this.helpers.httpRequest('https://example.com/1');
+const response2 = await this.helpers.requestWithAuthentication.call(this, 'oauth', options);
+const response3 = await this.helpers.requestOAuth2.call(this, 'google', options);`,
+						},
+					],
 				},
 				{
 					messageId: 'deprecatedRequestFunction',
@@ -67,10 +78,33 @@ const response3 = await this.helpers.requestOAuth2.call(this, 'google', options)
 						functionName: 'requestWithAuthentication',
 						replacement: 'httpRequestWithAuthentication',
 					},
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: {
+								functionName: 'requestWithAuthentication',
+								replacement: 'httpRequestWithAuthentication',
+							},
+							output: `
+const response1 = await this.helpers.request('https://example.com/1');
+const response2 = await this.helpers.httpRequestWithAuthentication.call(this, 'oauth', options);
+const response3 = await this.helpers.requestOAuth2.call(this, 'google', options);`,
+						},
+					],
 				},
 				{
 					messageId: 'deprecatedRequestFunction',
 					data: { functionName: 'requestOAuth2', replacement: 'httpRequestWithAuthentication' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: { functionName: 'requestOAuth2', replacement: 'httpRequestWithAuthentication' },
+							output: `
+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.httpRequestWithAuthentication.call(this, 'google', options);`,
+						},
+					],
 				},
 			],
 		},
@@ -86,14 +120,50 @@ function makeRequest(options: IRequestOptions): Promise<any> {
 				{
 					messageId: 'deprecatedType',
 					data: { typeName: 'IRequestOptions', replacement: 'IHttpRequestOptions' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceType',
+							data: { typeName: 'IRequestOptions', replacement: 'IHttpRequestOptions' },
+							output: `
+import { IHttpRequestOptions } from 'n8n-workflow';
+
+function makeRequest(options: IRequestOptions): Promise<any> {
+	return this.helpers.request(options);
+}`,
+						},
+					],
 				},
 				{
 					messageId: 'deprecatedType',
 					data: { typeName: 'IRequestOptions', replacement: 'IHttpRequestOptions' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceType',
+							data: { typeName: 'IRequestOptions', replacement: 'IHttpRequestOptions' },
+							output: `
+import { IRequestOptions } from 'n8n-workflow';
+
+function makeRequest(options: IHttpRequestOptions): Promise<any> {
+	return this.helpers.request(options);
+}`,
+						},
+					],
 				},
 				{
 					messageId: 'deprecatedRequestFunction',
 					data: { functionName: 'request', replacement: 'httpRequest' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: { functionName: 'request', replacement: 'httpRequest' },
+							output: `
+import { IRequestOptions } from 'n8n-workflow';
+
+function makeRequest(options: IRequestOptions): Promise<any> {
+	return this.helpers.httpRequest(options);
+}`,
+						},
+					],
 				},
 			],
 		},