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

package/src/rules/node-connection-type-literal.test.ts

@@ -0,0 +1,128 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { NodeConnectionTypeLiteralRule } from './node-connection-type-literal.js';
+
+const ruleTester = new RuleTester();
+
+function createNodeCode(inputs: string, outputs: string): string {
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { NodeConnectionTypes } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['input'],
+		version: 1,
+		description: 'A test node',
+		defaults: { name: 'Test Node' },
+		inputs: ${inputs},
+		outputs: ${outputs},
+		properties: [],
+	};
+}`;
+}
+
+function createNodeCodeNoImport(inputs: string, outputs: string): string {
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['input'],
+		version: 1,
+		description: 'A test node',
+		defaults: { name: 'Test Node' },
+		inputs: ${inputs},
+		outputs: ${outputs},
+		properties: [],
+	};
+}`;
+}
+
+function createNonNodeClass(): string {
+	return `
+export class RegularClass {
+	someProperty = 'value';
+}`;
+}
+
+ruleTester.run('node-connection-type-literal', NodeConnectionTypeLiteralRule, {
+	valid: [
+		{
+			name: 'class that does not implement INodeType',
+			code: createNonNodeClass(),
+		},
+		{
+			name: 'node with enum in inputs and outputs',
+			code: createNodeCode('[NodeConnectionTypes.Main]', '[NodeConnectionTypes.Main]'),
+		},
+		{
+			name: 'node with empty inputs and outputs',
+			code: createNodeCode('[]', '[]'),
+		},
+		{
+			name: 'node with AI enum in inputs',
+			code: createNodeCode('[NodeConnectionTypes.AiAgent]', '[NodeConnectionTypes.Main]'),
+		},
+		{
+			name: 'node with multiple enum values',
+			code: createNodeCode(
+				'[NodeConnectionTypes.Main]',
+				'[NodeConnectionTypes.AiAgent, NodeConnectionTypes.AiTool]',
+			),
+		},
+	],
+	invalid: [
+		{
+			name: 'string literal "main" in inputs',
+			code: createNodeCodeNoImport("['main']", '[NodeConnectionTypes.Main]'),
+			errors: [{ messageId: 'stringLiteralInInputs', data: { value: 'main', enumKey: 'Main' } }],
+			output: createNodeCodeNoImport('[NodeConnectionTypes.Main]', '[NodeConnectionTypes.Main]'),
+		},
+		{
+			name: 'string literal "main" in outputs',
+			code: createNodeCodeNoImport('[NodeConnectionTypes.Main]', "['main']"),
+			errors: [{ messageId: 'stringLiteralInOutputs', data: { value: 'main', enumKey: 'Main' } }],
+			output: createNodeCodeNoImport('[NodeConnectionTypes.Main]', '[NodeConnectionTypes.Main]'),
+		},
+		{
+			name: 'string literals in both inputs and outputs',
+			code: createNodeCodeNoImport("['main']", "['main']"),
+			errors: [
+				{ messageId: 'stringLiteralInInputs', data: { value: 'main', enumKey: 'Main' } },
+				{ messageId: 'stringLiteralInOutputs', data: { value: 'main', enumKey: 'Main' } },
+			],
+			output: createNodeCodeNoImport('[NodeConnectionTypes.Main]', '[NodeConnectionTypes.Main]'),
+		},
+		{
+			name: 'string literal "ai_agent" in inputs',
+			code: createNodeCodeNoImport("['ai_agent']", '[]'),
+			errors: [
+				{ messageId: 'stringLiteralInInputs', data: { value: 'ai_agent', enumKey: 'AiAgent' } },
+			],
+			output: createNodeCodeNoImport('[NodeConnectionTypes.AiAgent]', '[]'),
+		},
+		{
+			name: 'unknown string literal in inputs — no autofix',
+			code: createNodeCodeNoImport("['unknown_type']", '[]'),
+			errors: [{ messageId: 'unknownStringLiteralInInputs', data: { value: 'unknown_type' } }],
+			output: null,
+		},
+		{
+			name: 'unknown string literal in outputs — no autofix',
+			code: createNodeCodeNoImport('[]', "['unknown_type']"),
+			errors: [{ messageId: 'unknownStringLiteralInOutputs', data: { value: 'unknown_type' } }],
+			output: null,
+		},
+		{
+			name: 'string literal in node that already imports NodeConnectionTypes',
+			code: createNodeCode("['main']", '[NodeConnectionTypes.Main]'),
+			errors: [{ messageId: 'stringLiteralInInputs', data: { value: 'main', enumKey: 'Main' } }],
+			output: createNodeCode('[NodeConnectionTypes.Main]', '[NodeConnectionTypes.Main]'),
+		},
+	],
+});

package/src/rules/node-connection-type-literal.ts

@@ -0,0 +1,98 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import type { TSESTree } from '@typescript-eslint/utils';
+import { createRequire } from 'node:module';
+
+import {
+	isNodeTypeClass,
+	findClassProperty,
+	findObjectProperty,
+	createRule,
+} from '../utils/index.js';
+
+// n8n-workflow's ESM dist uses bare module specifiers that Node's native ESM
+// loader cannot resolve. Loading via CJS (createRequire) sidesteps this.
+const { NodeConnectionTypes } = createRequire(import.meta.url)('n8n-workflow') as {
+	NodeConnectionTypes: Record<string, string>;
+};
+
+// Reverse map: string value (e.g. 'main') → enum key name (e.g. 'Main').
+// Derived directly from NodeConnectionTypes so it stays in sync automatically.
+const VALUE_TO_ENUM_KEY: Record<string, string> = Object.fromEntries(
+	Object.entries(NodeConnectionTypes).map(([key, value]) => [value, key]),
+);
+
+export const NodeConnectionTypeLiteralRule = createRule({
+	name: 'node-connection-type-literal',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Disallow string literals in node description `inputs`/`outputs` — use `NodeConnectionTypes` enum instead',
+		},
+		messages: {
+			stringLiteralInInputs:
+				'Use NodeConnectionTypes.{{enumKey}} from "n8n-workflow" instead of the string literal "{{value}}" in "inputs".',
+			stringLiteralInOutputs:
+				'Use NodeConnectionTypes.{{enumKey}} from "n8n-workflow" instead of the string literal "{{value}}" in "outputs".',
+			unknownStringLiteralInInputs:
+				'Use the NodeConnectionTypes enum from "n8n-workflow" instead of the string literal "{{value}}" in "inputs".',
+			unknownStringLiteralInOutputs:
+				'Use the NodeConnectionTypes enum from "n8n-workflow" instead of the string literal "{{value}}" in "outputs".',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		function checkArrayElements(
+			elements: TSESTree.ArrayExpression['elements'],
+			property: 'inputs' | 'outputs',
+		) {
+			for (const element of elements) {
+				if (element?.type !== AST_NODE_TYPES.Literal) continue;
+				if (typeof element.value !== 'string') continue;
+
+				const value = element.value;
+				const enumKey = VALUE_TO_ENUM_KEY[value];
+
+				if (enumKey) {
+					context.report({
+						node: element,
+						messageId: property === 'inputs' ? 'stringLiteralInInputs' : 'stringLiteralInOutputs',
+						data: { value, enumKey },
+						fix(fixer) {
+							return fixer.replaceText(element, `NodeConnectionTypes.${enumKey}`);
+						},
+					});
+				} else {
+					context.report({
+						node: element,
+						messageId:
+							property === 'inputs'
+								? 'unknownStringLiteralInInputs'
+								: 'unknownStringLiteralInOutputs',
+						data: { value },
+					});
+				}
+			}
+		}
+
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) return;
+
+				const descriptionProperty = findClassProperty(node, 'description');
+				if (!descriptionProperty) return;
+
+				const descriptionValue = descriptionProperty.value;
+				if (descriptionValue?.type !== AST_NODE_TYPES.ObjectExpression) return;
+
+				for (const prop of ['inputs', 'outputs'] as const) {
+					const property = findObjectProperty(descriptionValue, prop);
+					if (property?.value.type !== AST_NODE_TYPES.ArrayExpression) continue;
+					checkArrayElements(property.value.elements, prop);
+				}
+			},
+		};
+	},
+});

package/src/rules/options-sorted-alphabetically.test.ts

@@ -0,0 +1,468 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { OptionsSortedAlphabeticallyRule } from './options-sorted-alphabetically.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('options-sorted-alphabetically', OptionsSortedAlphabeticallyRule, {
+	valid: [
+		{
+			name: 'resource options already sorted alphabetically',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'Contact', value: 'contact' },
+									{ name: 'Project', value: 'project' },
+									{ name: 'User', value: 'user' },
+								],
+								default: 'contact',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'operation options already sorted alphabetically',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Operation',
+								name: 'operation',
+								type: 'options',
+								options: [
+									{ name: 'Create', value: 'create' },
+									{ name: 'Delete', value: 'delete' },
+									{ name: 'Get', value: 'get' },
+									{ name: 'Update', value: 'update' },
+								],
+								default: 'get',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'non-ASCII names sorted correctly via localeCompare',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'Árbol', value: 'arbol' },
+									{ name: 'Empresa', value: 'empresa' },
+									{ name: 'Usuario', value: 'usuario' },
+								],
+								default: 'arbol',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'single option is trivially sorted',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'User', value: 'user' },
+								],
+								default: 'user',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'non-options type parameter is ignored',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Name',
+								name: 'name',
+								type: 'string',
+								default: '',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'non-node class is ignored',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				export class NotANode {
+					description = {
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'User', value: 'user' },
+									{ name: 'Contact', value: 'contact' },
+								],
+								default: 'user',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'non-.node.ts file is ignored',
+			filename: '/tmp/TestHelper.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'User', value: 'user' },
+									{ name: 'Contact', value: 'contact' },
+								],
+								default: 'user',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'description assigned from a variable is skipped',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				const desc: INodeTypeDescription = {} as INodeTypeDescription;
+
+				export class TestNode implements INodeType {
+					description = desc;
+				}
+			`,
+		},
+		{
+			name: 'node with no properties array is skipped',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+					};
+				}
+			`,
+		},
+		{
+			name: 'spread element in properties array is skipped gracefully',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				const extraProps = [{ displayName: 'Extra', name: 'extra', type: 'string', default: '' }];
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							...extraProps,
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'options with a spread element are skipped (dynamic options)',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				const extraOption = { name: 'Extra', value: 'extra' };
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'User', value: 'user' },
+									...([extraOption]),
+								],
+								default: 'user',
+							},
+						],
+					};
+				}
+			`,
+		},
+		{
+			name: 'options with a dynamic name value are skipped',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				const dynamicName = 'Dynamic';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: dynamicName, value: 'dynamic' },
+									{ name: 'User', value: 'user' },
+								],
+								default: 'user',
+							},
+						],
+					};
+				}
+			`,
+		},
+	],
+	invalid: [
+		{
+			name: 'resource options not sorted alphabetically',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'User', value: 'user' },
+									{ name: 'Contact', value: 'contact' },
+									{ name: 'Project', value: 'project' },
+								],
+								default: 'user',
+							},
+						],
+					};
+				}
+			`,
+			errors: [
+				{
+					messageId: 'optionsNotSorted',
+					data: { displayName: 'Resource', expectedOrder: 'Contact, Project, User' },
+				},
+			],
+		},
+		{
+			name: 'operation options not sorted alphabetically',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Operation',
+								name: 'operation',
+								type: 'options',
+								options: [
+									{ name: 'Update', value: 'update' },
+									{ name: 'Create', value: 'create' },
+									{ name: 'Delete', value: 'delete' },
+									{ name: 'Get', value: 'get' },
+								],
+								default: 'get',
+							},
+						],
+					};
+				}
+			`,
+			errors: [
+				{
+					messageId: 'optionsNotSorted',
+					data: { displayName: 'Operation', expectedOrder: 'Create, Delete, Get, Update' },
+				},
+			],
+		},
+		{
+			name: 'other options-type parameter not sorted alphabetically',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Model',
+								name: 'model',
+								type: 'options',
+								options: [
+									{ name: 'GPT-4', value: 'gpt-4' },
+									{ name: 'Claude', value: 'claude' },
+									{ name: 'Gemini', value: 'gemini' },
+								],
+								default: 'gpt-4',
+							},
+						],
+					};
+				}
+			`,
+			errors: [
+				{
+					messageId: 'optionsNotSorted',
+					data: { displayName: 'Model', expectedOrder: 'Claude, Gemini, GPT-4' },
+				},
+			],
+		},
+		{
+			name: 'options-type parameter without displayName falls back to "unknown"',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'User', value: 'user' },
+									{ name: 'Contact', value: 'contact' },
+								],
+								default: 'user',
+							},
+						],
+					};
+				}
+			`,
+			errors: [
+				{
+					messageId: 'optionsNotSorted',
+					data: { displayName: 'unknown', expectedOrder: 'Contact, User' },
+				},
+			],
+		},
+		{
+			name: 'multiple unsorted parameters each report an error',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description: INodeTypeDescription = {
+						displayName: 'Test Node',
+						name: 'testNode',
+						properties: [
+							{
+								displayName: 'Resource',
+								name: 'resource',
+								type: 'options',
+								options: [
+									{ name: 'User', value: 'user' },
+									{ name: 'Contact', value: 'contact' },
+								],
+								default: 'user',
+							},
+							{
+								displayName: 'Operation',
+								name: 'operation',
+								type: 'options',
+								options: [
+									{ name: 'Update', value: 'update' },
+									{ name: 'Create', value: 'create' },
+								],
+								default: 'create',
+							},
+						],
+					};
+				}
+			`,
+			errors: [
+				{
+					messageId: 'optionsNotSorted',
+					data: { displayName: 'Resource', expectedOrder: 'Contact, User' },
+				},
+				{
+					messageId: 'optionsNotSorted',
+					data: { displayName: 'Operation', expectedOrder: 'Create, Update' },
+				},
+			],
+		},
+	],
+});