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

package/src/rules/require-param-default.ts

@@ -0,0 +1,89 @@
+/**
+ * Requires every node parameter to declare a `default` property.
+ *
+ * A parameter is detected structurally: an object literal inside a node's
+ * `description` with `displayName`, `name`, and `type` all set to string
+ * literals — the shape every `INodeProperties` entry has. This avoids
+ * hardcoding the `NodePropertyTypes` union (which would silently go stale as
+ * new types are added) and naturally excludes `options`-array entries, which
+ * carry `name`/`value` but no `displayName`/`type`.
+ *
+ * Without a `default`, n8n cannot reliably initialise the parameter's value,
+ * which leads to inconsistent runtime behaviour in the editor and on execution.
+ */
+
+import { simpleTraverse } from '@typescript-eslint/typescript-estree';
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import {
+	createRule,
+	findClassProperty,
+	findObjectProperty,
+	getStringLiteralValue,
+	isFileType,
+	isNodeTypeClass,
+} from '../utils/index.js';
+
+/** Property keys an `INodeProperties` parameter always carries as string literals. */
+const REQUIRED_PARAM_KEYS = ['displayName', 'name', 'type'] as const;
+
+/** Returns true when the object literal has the shape of a node parameter. */
+function isNodeParameter(node: TSESTree.ObjectExpression): boolean {
+	return REQUIRED_PARAM_KEYS.every((key) => {
+		const property = findObjectProperty(node, key);
+		return property !== null && getStringLiteralValue(property.value) !== null;
+	});
+}
+
+export const RequireParamDefaultRule = createRule({
+	name: 'require-param-default',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Require every node parameter to declare a default value.',
+		},
+		messages: {
+			missingDefault:
+				"Node parameter '{{ name }}' is missing a `default` value. Add a `default` property so the parameter initialises consistently.",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!isFileType(context.filename, '.node.ts')) {
+			return {};
+		}
+
+		const reportIfMissingDefault = (node: TSESTree.ObjectExpression): void => {
+			if (!isNodeParameter(node) || findObjectProperty(node, 'default') !== null) {
+				return;
+			}
+			const nameProperty = findObjectProperty(node, 'name');
+			context.report({
+				node,
+				messageId: 'missingDefault',
+				data: { name: getStringLiteralValue(nameProperty?.value ?? null) ?? '' },
+			});
+		};
+
+		return {
+			// Scope to an INodeType class's `description`, then walk only that
+			// subtree, so helper classes and object literals elsewhere in the file
+			// (e.g. in method bodies) that share the parameter shape are ignored.
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) return;
+				const description = findClassProperty(node, 'description');
+				if (description?.value?.type !== AST_NODE_TYPES.ObjectExpression) return;
+
+				simpleTraverse(description.value, {
+					enter(child) {
+						if (child.type === AST_NODE_TYPES.ObjectExpression) {
+							reportIfMissingDefault(child);
+						}
+					},
+				});
+			},
+		};
+	},
+});

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',
+					});
+				}
+			},
+		};
+	},
+});

package/.turbo/turbo-build$colon$unchecked.log

@@ -1,4 +0,0 @@
-
-> @n8n/eslint-plugin-community-nodes@0.22.0 build:unchecked /home/runner/work/n8n/n8n/packages/@n8n/eslint-plugin-community-nodes
-> tsc --project tsconfig.build.json --noCheck
-