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

package/src/rules/no-duplicate-param-options.test.ts

@@ -0,0 +1,125 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { NoDuplicateParamOptionsRule } from './no-duplicate-param-options.js';
+
+const ruleTester = new RuleTester();
+
+function nodeCode(options: string, type = 'options'): string {
+	return `
+		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: '${type}',
+						options: [${options}],
+						default: '',
+					},
+				],
+			};
+		}
+	`;
+}
+
+ruleTester.run('no-duplicate-param-options', NoDuplicateParamOptionsRule, {
+	valid: [
+		{
+			name: 'non-INodeType class is skipped',
+			filename: '/tmp/TestNode.node.ts',
+			code: 'export class Foo {}',
+		},
+		{
+			name: 'unique names and values',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(`
+				{ name: 'Create', value: 'create' },
+				{ name: 'Delete', value: 'delete' },
+			`),
+		},
+		{
+			name: 'unique numeric values',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(`
+				{ name: 'One', value: 1 },
+				{ name: 'Two', value: 2 },
+			`),
+		},
+		{
+			name: 'multiOptions with unique options',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(
+				`
+				{ name: 'A', value: 'a' },
+				{ name: 'B', value: 'b' },
+			`,
+				'multiOptions',
+			),
+		},
+		{
+			name: 'non-node.ts file is skipped',
+			filename: '/tmp/TestNode.ts',
+			code: nodeCode(`
+				{ name: 'Dup', value: 'a' },
+				{ name: 'Dup', value: 'b' },
+			`),
+		},
+	],
+	invalid: [
+		{
+			name: 'duplicate name',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(`
+				{ name: 'Create', value: 'create' },
+				{ name: 'Create', value: 'create2' },
+			`),
+			errors: [{ messageId: 'duplicateName', data: { value: 'Create', displayName: 'Resource' } }],
+		},
+		{
+			name: 'duplicate value',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(`
+				{ name: 'Create', value: 'create' },
+				{ name: 'Make', value: 'create' },
+			`),
+			errors: [{ messageId: 'duplicateValue', data: { value: 'create', displayName: 'Resource' } }],
+		},
+		{
+			name: 'duplicate numeric value',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(`
+				{ name: 'One', value: 1 },
+				{ name: 'Uno', value: 1 },
+			`),
+			errors: [{ messageId: 'duplicateValue', data: { value: '1', displayName: 'Resource' } }],
+		},
+		{
+			name: 'duplicate name and value reported separately',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(`
+				{ name: 'Create', value: 'create' },
+				{ name: 'Create', value: 'create' },
+			`),
+			errors: [
+				{ messageId: 'duplicateName', data: { value: 'Create', displayName: 'Resource' } },
+				{ messageId: 'duplicateValue', data: { value: 'create', displayName: 'Resource' } },
+			],
+		},
+		{
+			name: 'duplicate in multiOptions',
+			filename: '/tmp/TestNode.node.ts',
+			code: nodeCode(
+				`
+				{ name: 'A', value: 'a' },
+				{ name: 'A', value: 'b' },
+			`,
+				'multiOptions',
+			),
+			errors: [{ messageId: 'duplicateName', data: { value: 'A', displayName: 'Resource' } }],
+		},
+	],
+});

package/src/rules/no-duplicate-param-options.ts

@@ -0,0 +1,125 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import {
+	isNodeTypeClass,
+	findClassProperty,
+	findObjectProperty,
+	getStringLiteralValue,
+	getLiteralValue,
+	isFileType,
+	createRule,
+} from '../utils/index.js';
+
+export const NoDuplicateParamOptionsRule = createRule({
+	name: 'no-duplicate-param-options',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow duplicate option names or values within a single node parameter',
+		},
+		messages: {
+			duplicateName: 'Duplicate option name "{{ value }}" in parameter "{{ displayName }}".',
+			duplicateValue: 'Duplicate option value "{{ value }}" in parameter "{{ displayName }}".',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!isFileType(context.filename, '.node.ts')) {
+			return {};
+		}
+
+		const checkProperty = (property: TSESTree.ObjectExpression): void => {
+			const typeProperty = findObjectProperty(property, 'type');
+			const type = typeProperty ? getStringLiteralValue(typeProperty.value) : null;
+			if (type !== 'options' && type !== 'multiOptions') {
+				return;
+			}
+
+			const optionsProperty = findObjectProperty(property, 'options');
+			if (
+				!optionsProperty?.value ||
+				optionsProperty.value.type !== AST_NODE_TYPES.ArrayExpression
+			) {
+				return;
+			}
+
+			const displayNameProperty = findObjectProperty(property, 'displayName');
+			const displayName =
+				(displayNameProperty ? getStringLiteralValue(displayNameProperty.value) : null) ??
+				'unknown';
+
+			const seenNames = new Set<string>();
+			const seenValues = new Set<string | number | boolean>();
+
+			for (const option of optionsProperty.value.elements) {
+				if (!option || option.type !== AST_NODE_TYPES.ObjectExpression) {
+					continue;
+				}
+
+				const nameProperty = findObjectProperty(option, 'name');
+				const name = nameProperty ? getStringLiteralValue(nameProperty.value) : null;
+				if (name !== null) {
+					if (seenNames.has(name)) {
+						context.report({
+							node: nameProperty!.value,
+							messageId: 'duplicateName',
+							data: { value: name, displayName },
+						});
+					}
+					seenNames.add(name);
+				}
+
+				const valueProperty = findObjectProperty(option, 'value');
+				const value = valueProperty ? getLiteralValue(valueProperty.value) : null;
+				if (value !== null) {
+					if (seenValues.has(value)) {
+						context.report({
+							node: valueProperty!.value,
+							messageId: 'duplicateValue',
+							data: { value: String(value), displayName },
+						});
+					}
+					seenValues.add(value);
+				}
+			}
+		};
+
+		const analyzeNodeDescription = (descriptionValue: TSESTree.Expression | null): void => {
+			if (!descriptionValue || descriptionValue.type !== AST_NODE_TYPES.ObjectExpression) {
+				return;
+			}
+
+			const propertiesProperty = findObjectProperty(descriptionValue, 'properties');
+			if (
+				!propertiesProperty?.value ||
+				propertiesProperty.value.type !== AST_NODE_TYPES.ArrayExpression
+			) {
+				return;
+			}
+
+			for (const property of propertiesProperty.value.elements) {
+				if (!property || property.type !== AST_NODE_TYPES.ObjectExpression) {
+					continue;
+				}
+				checkProperty(property);
+			}
+		};
+
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) {
+					return;
+				}
+
+				const descriptionProperty = findClassProperty(node, 'description');
+				if (!descriptionProperty) {
+					return;
+				}
+
+				analyzeNodeDescription(descriptionProperty.value);
+			},
+		};
+	},
+});

package/src/rules/require-mit-license.test.ts

@@ -0,0 +1,67 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { RequireMitLicenseRule } from './require-mit-license.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('require-mit-license', RequireMitLicenseRule, {
+	valid: [
+		{
+			name: 'license is MIT',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "license": "MIT" }',
+		},
+		{
+			name: 'non-package.json file is ignored',
+			filename: 'some-config.json',
+			code: '{ "name": "n8n-nodes-example", "license": "Apache-2.0" }',
+		},
+		{
+			name: 'nested objects are not checked',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "license": "MIT", "config": { "license": "Apache-2.0" } }',
+		},
+		{
+			name: 'objects inside arrays are not flagged',
+			filename: 'package.json',
+			code: `{
+				"name": "n8n-nodes-example",
+				"license": "MIT",
+				"contributors": [
+					{ "name": "Alice" },
+					{ "name": "Bob" }
+				]
+			}`,
+		},
+	],
+	invalid: [
+		{
+			name: 'missing license field',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+			output: '{ "name": "n8n-nodes-example", "version": "1.0.0", "license": "MIT" }',
+			errors: [{ messageId: 'missingLicense' }],
+		},
+		{
+			name: 'empty package.json object',
+			filename: 'package.json',
+			code: '{}',
+			output: '{ "license": "MIT" }',
+			errors: [{ messageId: 'missingLicense' }],
+		},
+		{
+			name: 'wrong license value',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "license": "Apache-2.0" }',
+			output: '{ "name": "n8n-nodes-example", "license": "MIT" }',
+			errors: [{ messageId: 'wrongLicense' }],
+		},
+		{
+			name: 'case-mismatched license value',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "license": "mit" }',
+			output: '{ "name": "n8n-nodes-example", "license": "MIT" }',
+			errors: [{ messageId: 'wrongLicense' }],
+		},
+	],
+});

package/src/rules/require-mit-license.ts

@@ -0,0 +1,65 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import { createRule, findJsonProperty, getStringLiteralValue } from '../utils/index.js';
+
+const REQUIRED_LICENSE = 'MIT';
+
+export const RequireMitLicenseRule = createRule({
+	name: 'require-mit-license',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Require the "license" field in community node package.json to be "MIT"',
+		},
+		fixable: 'code',
+		messages: {
+			missingLicense: `The package.json must have a "license" field set to "${REQUIRED_LICENSE}".`,
+			wrongLicense: `The "license" field must be "${REQUIRED_LICENSE}".`,
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!context.filename.endsWith('package.json')) {
+			return {};
+		}
+
+		return {
+			ObjectExpression(node: TSESTree.ObjectExpression) {
+				if (node.parent?.type !== AST_NODE_TYPES.ExpressionStatement) {
+					return;
+				}
+
+				const licenseProp = findJsonProperty(node, 'license');
+
+				if (!licenseProp) {
+					context.report({
+						node,
+						messageId: 'missingLicense',
+						fix(fixer) {
+							const lastProp = node.properties[node.properties.length - 1];
+							if (!lastProp) {
+								return fixer.replaceText(node, `{ "license": "${REQUIRED_LICENSE}" }`);
+							}
+							return fixer.insertTextAfter(lastProp, `, "license": "${REQUIRED_LICENSE}"`);
+						},
+					});
+					return;
+				}
+
+				if (getStringLiteralValue(licenseProp.value) === REQUIRED_LICENSE) {
+					return;
+				}
+
+				context.report({
+					node: licenseProp.value,
+					messageId: 'wrongLicense',
+					fix(fixer) {
+						return fixer.replaceText(licenseProp.value, `"${REQUIRED_LICENSE}"`);
+					},
+				});
+			},
+		};
+	},
+});

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

@@ -0,0 +1,227 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { RequireParamDefaultRule } from './require-param-default.js';
+
+const ruleTester = new RuleTester();
+
+function createNodeCode(properties: 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: [],
+				outputs: [],
+				properties: [
+					${properties}
+				],
+			};
+		}
+	`;
+}
+
+ruleTester.run('require-param-default', RequireParamDefaultRule, {
+	valid: [
+		{
+			name: 'class that does not implement INodeType',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				export class NotANode {
+					description = {
+						properties: [{ displayName: 'Field', name: 'field', type: 'string' }],
+					};
+				}
+			`,
+		},
+		{
+			name: 'param-shaped object outside description (e.g. in a method) 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: [],
+					};
+
+					methods = {
+						loadOptions: {
+							async getThings() {
+								const config = { displayName: 'X', name: 'x', type: 'string' };
+								return [config];
+							},
+						},
+					};
+				}
+			`,
+		},
+		{
+			name: 'non .node.ts file is ignored',
+			filename: '/tmp/helper.ts',
+			code: `
+				export class TestNode {
+					description = {
+						properties: [{ displayName: 'Field', name: 'field', type: 'string' }],
+					};
+				}
+			`,
+		},
+		{
+			name: 'string parameter with default',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Field',
+					name: 'field',
+					type: 'string',
+					default: '',
+				},
+			`),
+		},
+		{
+			name: 'options parameter with default',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Operation',
+					name: 'operation',
+					type: 'options',
+					options: [{ name: 'Create', value: 'create' }],
+					default: 'create',
+				},
+			`),
+		},
+		{
+			name: 'notice parameter with empty default',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Some notice',
+					name: 'notice',
+					type: 'notice',
+					default: '',
+				},
+			`),
+		},
+		{
+			name: 'options-array entries (name/value, no displayName) are not parameters',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Operation',
+					name: 'operation',
+					type: 'options',
+					options: [{ name: 'Create', value: 'create', type: 'whatever' }],
+					default: 'create',
+				},
+			`),
+		},
+		{
+			name: 'object with name and type but no displayName is not a parameter',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Routing',
+					name: 'routing',
+					type: 'string',
+					default: '',
+					routing: { request: { method: 'GET', name: 'x', type: 'y' } },
+				},
+			`),
+		},
+		{
+			name: 'nested collection options all have defaults',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Additional Fields',
+					name: 'additionalFields',
+					type: 'collection',
+					default: {},
+					options: [
+						{
+							displayName: 'Limit',
+							name: 'limit',
+							type: 'number',
+							default: 50,
+						},
+					],
+				},
+			`),
+		},
+	],
+	invalid: [
+		{
+			name: 'string parameter missing default',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Field',
+					name: 'field',
+					type: 'string',
+				},
+			`),
+			errors: [{ messageId: 'missingDefault', data: { name: 'field' } }],
+		},
+		{
+			name: 'notice parameter missing default',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Some notice',
+					name: 'notice',
+					type: 'notice',
+				},
+			`),
+			errors: [{ messageId: 'missingDefault', data: { name: 'notice' } }],
+		},
+		{
+			name: 'nested collection option missing default',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'Additional Fields',
+					name: 'additionalFields',
+					type: 'collection',
+					default: {},
+					options: [
+						{
+							displayName: 'Limit',
+							name: 'limit',
+							type: 'number',
+						},
+					],
+				},
+			`),
+			errors: [{ messageId: 'missingDefault', data: { name: 'limit' } }],
+		},
+		{
+			name: 'multiple parameters missing defaults',
+			filename: '/tmp/TestNode.node.ts',
+			code: createNodeCode(`
+				{
+					displayName: 'First',
+					name: 'first',
+					type: 'string',
+				},
+				{
+					displayName: 'Second',
+					name: 'second',
+					type: 'boolean',
+				},
+			`),
+			errors: [
+				{ messageId: 'missingDefault', data: { name: 'first' } },
+				{ messageId: 'missingDefault', data: { name: 'second' } },
+			],
+		},
+	],
+});

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