@n8n/eslint-plugin-community-nodes 0.22.0 → 0.23.0

package/src/rules/trigger-node-conventions.test.ts

@@ -0,0 +1,110 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { TriggerNodeConventionsRule } from './trigger-node-conventions.js';
+
+const ruleTester = new RuleTester();
+
+function createNodeCode(options: {
+	className: string;
+	name: string;
+	displayName: string;
+	inputs: string;
+}): string {
+	const { className, name, displayName, inputs } = options;
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class ${className} implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: '${displayName}',
+    name: '${name}',
+    group: ['trigger'],
+    version: 1,
+    description: 'A test node',
+    defaults: { name: '${displayName}' },
+    inputs: ${inputs},
+    outputs: ['main'],
+    properties: [],
+  };
+}`;
+}
+
+ruleTester.run('trigger-node-conventions', TriggerNodeConventionsRule, {
+	valid: [
+		{
+			name: 'class that does not implement INodeType',
+			filename: 'MyTrigger.node.ts',
+			code: 'export class MyTrigger {}',
+		},
+		{
+			name: 'non-trigger node class is ignored',
+			filename: 'My.node.ts',
+			code: createNodeCode({
+				className: 'My',
+				name: 'my',
+				displayName: 'My Node',
+				inputs: "['main']",
+			}),
+		},
+		{
+			name: 'compliant trigger node',
+			filename: 'MyTrigger.node.ts',
+			code: createNodeCode({
+				className: 'MyTrigger',
+				name: 'myTrigger',
+				displayName: 'My Trigger',
+				inputs: '[]',
+			}),
+		},
+	],
+	invalid: [
+		{
+			name: 'name missing Trigger suffix',
+			filename: 'MyTrigger.node.ts',
+			code: createNodeCode({
+				className: 'MyTrigger',
+				name: 'my',
+				displayName: 'My Trigger',
+				inputs: '[]',
+			}),
+			errors: [{ messageId: 'nameMissingSuffix', data: { value: 'my' } }],
+		},
+		{
+			name: 'displayName missing Trigger',
+			filename: 'MyTrigger.node.ts',
+			code: createNodeCode({
+				className: 'MyTrigger',
+				name: 'myTrigger',
+				displayName: 'My Node',
+				inputs: '[]',
+			}),
+			errors: [{ messageId: 'displayNameMissingTrigger', data: { value: 'My Node' } }],
+		},
+		{
+			name: 'inputs is not empty',
+			filename: 'MyTrigger.node.ts',
+			code: createNodeCode({
+				className: 'MyTrigger',
+				name: 'myTrigger',
+				displayName: 'My Trigger',
+				inputs: "['main']",
+			}),
+			errors: [{ messageId: 'inputsNotEmpty' }],
+		},
+		{
+			name: 'all three violations at once',
+			filename: 'MyTrigger.node.ts',
+			code: createNodeCode({
+				className: 'MyTrigger',
+				name: 'my',
+				displayName: 'My Node',
+				inputs: "['main']",
+			}),
+			errors: [
+				{ messageId: 'displayNameMissingTrigger' },
+				{ messageId: 'nameMissingSuffix' },
+				{ messageId: 'inputsNotEmpty' },
+			],
+		},
+	],
+});

package/src/rules/trigger-node-conventions.ts

@@ -0,0 +1,92 @@
+import { TSESTree } from '@typescript-eslint/utils';
+
+import {
+	isNodeTypeClass,
+	findClassProperty,
+	findObjectProperty,
+	getStringLiteralValue,
+	isFileType,
+	createRule,
+} from '../utils/index.js';
+
+export const TriggerNodeConventionsRule = createRule({
+	name: 'trigger-node-conventions',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Trigger nodes (class name ends with `Trigger`) must label themselves consistently as triggers',
+		},
+		messages: {
+			nameMissingSuffix: "Trigger node `description.name` '{{value}}' must end with 'Trigger'",
+			displayNameMissingTrigger:
+				"Trigger node `description.displayName` '{{value}}' must contain 'Trigger'",
+			inputsNotEmpty: 'Trigger node `description.inputs` must be an empty array `[]`',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!isFileType(context.filename, '.node.ts')) {
+			return {};
+		}
+
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) {
+					return;
+				}
+
+				if (!node.id?.name.endsWith('Trigger')) {
+					return;
+				}
+
+				const descriptionProperty = findClassProperty(node, 'description');
+				if (descriptionProperty?.value?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
+					return;
+				}
+				const description = descriptionProperty.value;
+
+				const displayNameProperty = findObjectProperty(description, 'displayName');
+				const displayNameValue = displayNameProperty
+					? getStringLiteralValue(displayNameProperty.value)
+					: null;
+				if (
+					displayNameProperty &&
+					displayNameValue !== null &&
+					!displayNameValue.includes('Trigger')
+				) {
+					context.report({
+						node: displayNameProperty.value,
+						messageId: 'displayNameMissingTrigger',
+						data: { value: displayNameValue },
+					});
+				}
+
+				const nameProperty = findObjectProperty(description, 'name');
+				const nameValue = nameProperty ? getStringLiteralValue(nameProperty.value) : null;
+				if (nameProperty && nameValue !== null && !nameValue.endsWith('Trigger')) {
+					context.report({
+						node: nameProperty.value,
+						messageId: 'nameMissingSuffix',
+						data: { value: nameValue },
+					});
+				}
+
+				const inputsProperty = findObjectProperty(description, 'inputs');
+				if (
+					inputsProperty &&
+					!(
+						inputsProperty.value.type === TSESTree.AST_NODE_TYPES.ArrayExpression &&
+						inputsProperty.value.elements.length === 0
+					)
+				) {
+					context.report({
+						node: inputsProperty.value,
+						messageId: 'inputsNotEmpty',
+					});
+				}
+			},
+		};
+	},
+});