@n8n/eslint-plugin-community-nodes 0.4.0 → 0.6.0

package/src/rules/credential-documentation-url.test.ts

@@ -0,0 +1,306 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { CredentialDocumentationUrlRule } from './credential-documentation-url.js';
+
+const ruleTester = new RuleTester();
+
+function createCredentialCode(documentationUrl: string): string {
+	return `
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class TestCredential implements ICredentialType {
+	name = 'testApi';
+	displayName = 'Test API';
+	documentationUrl = '${documentationUrl}';
+
+	properties: INodeProperties[] = [];
+}`;
+}
+
+function createCredentialWithoutDocUrl(): string {
+	return `
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class TestCredential implements ICredentialType {
+	name = 'testApi';
+	displayName = 'Test API';
+
+	properties: INodeProperties[] = [];
+}`;
+}
+
+function createRegularClass(): string {
+	return `
+export class RegularClass {
+	documentationUrl = 'invalid-url';
+}`;
+}
+
+ruleTester.run('credential-documentation-url', CredentialDocumentationUrlRule, {
+	valid: [
+		{
+			name: 'valid URL with default options (URLs only)',
+			code: createCredentialCode('https://example.com/docs'),
+		},
+		{
+			name: 'valid URL with explicit options',
+			code: createCredentialCode('https://example.com/docs'),
+			options: [{ allowUrls: true, allowSlugs: false }],
+		},
+		{
+			name: 'valid lowercase slug when slugs are allowed',
+			code: createCredentialCode('myservice'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+		},
+		{
+			name: 'valid lowercase slug with slashes when slugs are allowed',
+			code: createCredentialCode('myservice/advanced/config'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+		},
+		{
+			name: 'valid URL when both URLs and slugs are allowed',
+			code: createCredentialCode('https://example.com/docs'),
+			options: [{ allowUrls: true, allowSlugs: true }],
+		},
+		{
+			name: 'valid lowercase slug when both URLs and slugs are allowed',
+			code: createCredentialCode('myservice/config'),
+			options: [{ allowUrls: true, allowSlugs: true }],
+		},
+		{
+			name: 'credential without documentationUrl should not trigger',
+			code: createCredentialWithoutDocUrl(),
+		},
+		{
+			name: 'class not implementing ICredentialType should be ignored',
+			code: createRegularClass(),
+		},
+		{
+			name: 'valid lowercase slug with multiple segments',
+			code: createCredentialCode('myservice/somefeature/advancedconfig'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+		},
+		{
+			name: 'valid lowercase alphanumeric slug',
+			code: createCredentialCode('myservice123'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+		},
+		{
+			name: 'valid lowercase alphanumeric slug with slashes',
+			code: createCredentialCode('myservice123/config456'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+		},
+	],
+	invalid: [
+		{
+			name: 'invalid URL with default options',
+			code: createCredentialCode('invalid-url'),
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'invalid-url',
+						expectedFormats: 'a valid URL',
+					},
+				},
+			],
+		},
+		{
+			name: 'slug not allowed with default options',
+			code: createCredentialCode('myservice'),
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'myservice',
+						expectedFormats: 'a valid URL',
+					},
+				},
+			],
+		},
+		{
+			name: 'slug with special characters should not be autofixable',
+			code: createCredentialCode('My-Service'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'My-Service',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'uppercase slug should be autofixable',
+			code: createCredentialCode('MyService'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			output: createCredentialCode('myservice'),
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'MyService',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'invalid URL when only URLs are allowed',
+			code: createCredentialCode('not-a-valid-url'),
+			options: [{ allowUrls: true, allowSlugs: false }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'not-a-valid-url',
+						expectedFormats: 'a valid URL',
+					},
+				},
+			],
+		},
+		{
+			name: 'invalid when neither URLs nor slugs are allowed',
+			code: createCredentialCode('https://example.com'),
+			options: [{ allowUrls: false, allowSlugs: false }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'https://example.com',
+						expectedFormats: 'a valid format (none configured)',
+					},
+				},
+			],
+		},
+		{
+			name: 'slug with invalid characters (special chars) should not be autofixable',
+			code: createCredentialCode('my@service/config'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'my@service/config',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'slug with uppercase segment should be autofixable',
+			code: createCredentialCode('myService/Config'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			output: createCredentialCode('myservice/config'),
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'myService/Config',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'slug with hyphens should not be autofixable',
+			code: createCredentialCode('myservice/advanced-config'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'myservice/advanced-config',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'slug with underscores should not be autofixable',
+			code: createCredentialCode('my_service/config_advanced'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'my_service/config_advanced',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'invalid value when both formats are allowed - shows both in error message',
+			code: createCredentialCode('Invalid-Value!'),
+			options: [{ allowUrls: true, allowSlugs: true }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'Invalid-Value!',
+						expectedFormats: 'a valid URL or a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'empty string should be invalid with default options',
+			code: createCredentialCode(''),
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: '',
+						expectedFormats: 'a valid URL',
+					},
+				},
+			],
+		},
+		{
+			name: 'empty string should be invalid when slugs are allowed',
+			code: createCredentialCode(''),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: '',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'mixed case slug with numbers should be autofixable',
+			code: createCredentialCode('MyService123/Config456'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			output: createCredentialCode('myservice123/config456'),
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: 'MyService123/Config456',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+		{
+			name: 'slug starting with number should be invalid and not autofixable',
+			code: createCredentialCode('123service/config'),
+			options: [{ allowUrls: false, allowSlugs: true }],
+			errors: [
+				{
+					messageId: 'invalidDocumentationUrl',
+					data: {
+						value: '123service/config',
+						expectedFormats: 'a lowercase alphanumeric slug (can contain slashes)',
+					},
+				},
+			],
+		},
+	],
+});

package/src/rules/credential-documentation-url.ts

@@ -0,0 +1,129 @@
+import {
+	isCredentialTypeClass,
+	findClassProperty,
+	getStringLiteralValue,
+	createRule,
+} from '../utils/index.js';
+
+type RuleOptions = {
+	allowUrls?: boolean;
+	allowSlugs?: boolean;
+};
+
+const DEFAULT_OPTIONS: RuleOptions = {
+	allowUrls: true,
+	allowSlugs: false,
+};
+
+function isValidUrl(value: string): boolean {
+	try {
+		new URL(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function isValidSlug(value: string): boolean {
+	// TODO: Remove this special case once these slugs are updated
+	if (
+		['google/service-account', 'google/oauth-single-service', 'google/oauth-generic'].includes(
+			value,
+		)
+	)
+		return true;
+
+	return value.split('/').every((segment) => /^[a-z][a-z0-9]*$/.test(segment));
+}
+
+function hasOnlyCaseIssues(value: string): boolean {
+	return value.split('/').every((segment) => /^[a-zA-Z][a-zA-Z0-9]*$/.test(segment));
+}
+
+function validateDocumentationUrl(value: string, options: RuleOptions): boolean {
+	return (!!options.allowUrls && isValidUrl(value)) || (!!options.allowSlugs && isValidSlug(value));
+}
+
+function getExpectedFormatsMessage(options: RuleOptions): string {
+	const formats = [
+		...(options.allowUrls ? ['a valid URL'] : []),
+		...(options.allowSlugs ? ['a lowercase alphanumeric slug (can contain slashes)'] : []),
+	];
+
+	if (formats.length === 0) return 'a valid format (none configured)';
+	if (formats.length === 1) return formats[0]!;
+	return formats.slice(0, -1).join(', ') + ' or ' + formats[formats.length - 1];
+}
+
+export const CredentialDocumentationUrlRule = createRule({
+	name: 'credential-documentation-url',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Enforce valid credential documentationUrl format (URL or lowercase alphanumeric slug)',
+		},
+		messages: {
+			invalidDocumentationUrl: "documentationUrl '{{ value }}' must be {{ expectedFormats }}",
+		},
+		fixable: 'code',
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					allowUrls: {
+						type: 'boolean',
+						description: 'Whether to allow valid URLs',
+					},
+					allowSlugs: {
+						type: 'boolean',
+						description: 'Whether to allow lowercase alphanumeric slugs with slashes',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+	},
+	defaultOptions: [DEFAULT_OPTIONS],
+	create(context, [options = {}]) {
+		const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+
+		return {
+			ClassDeclaration(node) {
+				if (!isCredentialTypeClass(node)) {
+					return;
+				}
+
+				const documentationUrlProperty = findClassProperty(node, 'documentationUrl');
+				if (!documentationUrlProperty?.value) {
+					return;
+				}
+
+				const documentationUrl = getStringLiteralValue(documentationUrlProperty.value);
+				if (documentationUrl === null) {
+					return;
+				}
+
+				if (!validateDocumentationUrl(documentationUrl, mergedOptions)) {
+					const canAutofix = !!mergedOptions.allowSlugs && hasOnlyCaseIssues(documentationUrl);
+
+					context.report({
+						node: documentationUrlProperty.value,
+						messageId: 'invalidDocumentationUrl',
+						data: {
+							value: documentationUrl,
+							expectedFormats: getExpectedFormatsMessage(mergedOptions),
+						},
+						fix: canAutofix
+							? (fixer) =>
+									fixer.replaceText(
+										documentationUrlProperty.value!,
+										`'${documentationUrl.toLowerCase()}'`,
+									)
+							: undefined,
+					});
+				}
+			},
+		};
+	},
+});

package/src/rules/credential-password-field.test.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { CredentialPasswordFieldRule } from './credential-password-field.js';
 
 const ruleTester = new RuleTester();

package/src/rules/credential-password-field.ts

@@ -1,10 +1,13 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+import { TSESTree } from '@typescript-eslint/types';
+import type { ReportFixFunction } from '@typescript-eslint/utils/ts-eslint';
+
 import {
 	isCredentialTypeClass,
 	findClassProperty,
 	findObjectProperty,
 	getStringLiteralValue,
 	getBooleanLiteralValue,
+	createRule,
 } from '../utils/index.js';
 
 const SENSITIVE_PATTERNS = [
@@ -31,10 +34,10 @@ function isSensitiveFieldName(name: string): boolean {
 	return SENSITIVE_PATTERNS.some((pattern) => lowerName.includes(pattern));
 }
 
-function hasPasswordTypeOption(element: any): boolean {
+function hasPasswordTypeOption(element: TSESTree.ObjectExpression): boolean {
 	const typeOptionsProperty = findObjectProperty(element, 'typeOptions');
 
-	if (typeOptionsProperty?.value?.type !== 'ObjectExpression') {
+	if (typeOptionsProperty?.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
 		return false;
 	}
 
@@ -44,31 +47,43 @@ function hasPasswordTypeOption(element: any): boolean {
 	return passwordValue === true;
 }
 
-function createPasswordFix(element: any, typeOptionsProperty: any) {
-	return function (fixer: any) {
-		if (typeOptionsProperty?.value?.type === 'ObjectExpression') {
+function createPasswordFix(
+	element: TSESTree.ObjectExpression,
+	typeOptionsProperty: TSESTree.Property | null,
+): ReportFixFunction {
+	return (fixer) => {
+		if (typeOptionsProperty?.value.type === TSESTree.AST_NODE_TYPES.ObjectExpression) {
 			const passwordProperty = findObjectProperty(typeOptionsProperty.value, 'password');
 
 			if (passwordProperty) {
 				return fixer.replaceText(passwordProperty.value, 'true');
 			}
 
-			if (typeOptionsProperty.value.properties.length > 0) {
-				const lastProperty =
-					typeOptionsProperty.value.properties[typeOptionsProperty.value.properties.length - 1];
-				return lastProperty ? fixer.insertTextAfter(lastProperty, ', password: true') : null;
+			const objectValue = typeOptionsProperty.value;
+			if (objectValue.properties.length > 0) {
+				const lastProperty = objectValue.properties[objectValue.properties.length - 1];
+				if (lastProperty) {
+					return fixer.insertTextAfter(lastProperty, ', password: true');
+				}
 			} else {
-				const openBrace = typeOptionsProperty.value.range![0] + 1;
-				return fixer.insertTextAfterRange([openBrace, openBrace], ' password: true ');
+				const range = objectValue.range;
+				if (range) {
+					const openBrace = range[0] + 1;
+					return fixer.insertTextAfterRange([openBrace, openBrace], ' password: true ');
+				}
 			}
 		}
 
 		const lastProperty = element.properties[element.properties.length - 1];
-		return fixer.insertTextAfter(lastProperty, ',\n\t\t\ttypeOptions: { password: true }');
+		if (lastProperty) {
+			return fixer.insertTextAfter(lastProperty, ',\n\t\t\ttypeOptions: { password: true }');
+		}
+		return null;
 	};
 }
 
-export const CredentialPasswordFieldRule = ESLintUtils.RuleCreator.withoutDocs({
+export const CredentialPasswordFieldRule = createRule({
+	name: 'credential-password-field',
 	meta: {
 		type: 'problem',
 		docs: {
@@ -90,12 +105,15 @@ export const CredentialPasswordFieldRule = ESLintUtils.RuleCreator.withoutDocs({
 				}
 
 				const propertiesProperty = findClassProperty(node, 'properties');
-				if (!propertiesProperty?.value || propertiesProperty.value.type !== 'ArrayExpression') {
+				if (
+					!propertiesProperty?.value ||
+					propertiesProperty.value.type !== TSESTree.AST_NODE_TYPES.ArrayExpression
+				) {
 					return;
 				}
 
 				for (const element of propertiesProperty.value.elements) {
-					if (element?.type !== 'ObjectExpression') {
+					if (element?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
 						continue;
 					}