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

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

@@ -1,129 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-
-import {
-	isNodeTypeClass,
-	findClassProperty,
-	findObjectProperty,
-	getStringLiteralValue,
-	isFileType,
-	createRule,
-} from '../utils/index.js';
-
-export const OptionsSortedAlphabeticallyRule = createRule({
-	name: 'options-sorted-alphabetically',
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce alphabetical ordering of options arrays in n8n node properties',
-		},
-		messages: {
-			optionsNotSorted:
-				'Options in "{{ displayName }}" are not sorted alphabetically. Expected order: {{ expectedOrder }}.',
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		if (!isFileType(context.filename, '.node.ts')) {
-			return {};
-		}
-
-		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;
-				}
-
-				const typeProperty = findObjectProperty(property, 'type');
-				const type = typeProperty ? getStringLiteralValue(typeProperty.value) : null;
-
-				if (type !== 'options') {
-					continue;
-				}
-
-				const optionsProperty = findObjectProperty(property, 'options');
-				if (
-					!optionsProperty?.value ||
-					optionsProperty.value.type !== AST_NODE_TYPES.ArrayExpression
-				) {
-					continue;
-				}
-
-				const optionsArray = optionsProperty.value;
-
-				// Extract all option names; skip if any name is non-literal (dynamic options)
-				const names: string[] = [];
-				let hasDynamicName = false;
-
-				for (const option of optionsArray.elements) {
-					if (!option || option.type !== AST_NODE_TYPES.ObjectExpression) {
-						hasDynamicName = true;
-						break;
-					}
-					const nameProperty = findObjectProperty(option, 'name');
-					const name = nameProperty ? getStringLiteralValue(nameProperty.value) : null;
-					if (name === null) {
-						hasDynamicName = true;
-						break;
-					}
-					names.push(name);
-				}
-
-				if (hasDynamicName || names.length <= 1) {
-					continue;
-				}
-
-				const sorted = [...names].sort((a, b) =>
-					a.localeCompare(b, undefined, { sensitivity: 'base' }),
-				);
-
-				const isSorted = names.every((name, i) => name === sorted[i]);
-				if (isSorted) {
-					continue;
-				}
-
-				const displayNameProperty = findObjectProperty(property, 'displayName');
-				const displayName =
-					(displayNameProperty ? getStringLiteralValue(displayNameProperty.value) : null) ??
-					'unknown';
-
-				context.report({
-					node: optionsArray,
-					messageId: 'optionsNotSorted',
-					data: {
-						displayName,
-						expectedOrder: sorted.join(', '),
-					},
-				});
-			}
-		};
-
-		return {
-			ClassDeclaration(node) {
-				if (!isNodeTypeClass(node)) {
-					return;
-				}
-
-				const descriptionProperty = findClassProperty(node, 'description');
-				if (!descriptionProperty) {
-					return;
-				}
-
-				analyzeNodeDescription(descriptionProperty.value);
-			},
-		};
-	},
-});

package/src/rules/require-community-node-keyword.test.ts

@@ -1,82 +0,0 @@
-import { RuleTester } from '@typescript-eslint/rule-tester';
-
-import { RequireCommunityNodeKeywordRule } from './require-community-node-keyword.js';
-
-const ruleTester = new RuleTester();
-
-ruleTester.run('require-community-node-keyword', RequireCommunityNodeKeywordRule, {
-	valid: [
-		{
-			name: 'keywords array contains required keyword',
-			filename: 'package.json',
-			code: '{ "name": "n8n-nodes-example", "keywords": ["n8n-community-node-package"] }',
-		},
-		{
-			name: 'keywords array contains required keyword among others',
-			filename: 'package.json',
-			code: '{ "name": "n8n-nodes-example", "keywords": ["n8n", "automation", "n8n-community-node-package", "workflow"] }',
-		},
-		{
-			name: 'non-package.json file is ignored',
-			filename: 'some-config.json',
-			code: '{ "name": "n8n-nodes-example" }',
-		},
-		{
-			name: 'nested objects are not checked',
-			filename: 'package.json',
-			code: '{ "name": "n8n-nodes-example", "keywords": ["n8n-community-node-package"], "config": { "nested": "value" } }',
-		},
-		{
-			name: 'objects inside arrays (e.g. contributors) are not flagged',
-			filename: 'package.json',
-			code: `{
-				"name": "n8n-nodes-example",
-				"keywords": ["n8n-community-node-package"],
-				"contributors": [
-					{ "name": "Alice", "email": "alice@example.com" },
-					{ "name": "Bob", "email": "bob@example.com" }
-				]
-			}`,
-		},
-	],
-	invalid: [
-		{
-			name: 'missing keywords array entirely',
-			filename: 'package.json',
-			code: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
-			output:
-				'{ "name": "n8n-nodes-example", "version": "1.0.0", "keywords": ["n8n-community-node-package"] }',
-			errors: [{ messageId: 'missingKeywordsArray' }],
-		},
-		{
-			name: 'empty keywords array',
-			filename: 'package.json',
-			code: '{ "name": "n8n-nodes-example", "keywords": [] }',
-			output: '{ "name": "n8n-nodes-example", "keywords": ["n8n-community-node-package"] }',
-			errors: [{ messageId: 'missingKeyword' }],
-		},
-		{
-			name: 'keywords array without the required keyword',
-			filename: 'package.json',
-			code: '{ "name": "n8n-nodes-example", "keywords": ["n8n", "automation"] }',
-			output:
-				'{ "name": "n8n-nodes-example", "keywords": ["n8n", "automation", "n8n-community-node-package"] }',
-			errors: [{ messageId: 'missingKeyword' }],
-		},
-		{
-			name: 'keywords array with similar but incorrect keyword',
-			filename: 'package.json',
-			code: '{ "name": "n8n-nodes-example", "keywords": ["n8n-community-node"] }',
-			output:
-				'{ "name": "n8n-nodes-example", "keywords": ["n8n-community-node", "n8n-community-node-package"] }',
-			errors: [{ messageId: 'missingKeyword' }],
-		},
-		{
-			name: 'empty package.json object',
-			filename: 'package.json',
-			code: '{}',
-			output: '{ "keywords": ["n8n-community-node-package"] }',
-			errors: [{ messageId: 'missingKeywordsArray' }],
-		},
-	],
-});

package/src/rules/require-community-node-keyword.ts

@@ -1,78 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-
-import { createRule, findJsonProperty } from '../utils/index.js';
-
-const REQUIRED_KEYWORD = 'n8n-community-node-package';
-
-export const RequireCommunityNodeKeywordRule = createRule({
-	name: 'require-community-node-keyword',
-	meta: {
-		type: 'problem',
-		docs: {
-			description:
-				'Require the "n8n-community-node-package" keyword in community node package.json',
-		},
-		fixable: 'code',
-		messages: {
-			missingKeyword: `The "keywords" array must include "${REQUIRED_KEYWORD}". This keyword is required for n8n to discover community node packages.`,
-			missingKeywordsArray: `The package.json must have a "keywords" array containing "${REQUIRED_KEYWORD}".`,
-		},
-		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 keywordsProp = findJsonProperty(node, 'keywords');
-
-				if (!keywordsProp) {
-					context.report({
-						node,
-						messageId: 'missingKeywordsArray',
-						fix(fixer) {
-							const lastProp = node.properties[node.properties.length - 1];
-							if (!lastProp) {
-								return fixer.replaceText(node, `{ "keywords": ["${REQUIRED_KEYWORD}"] }`);
-							}
-							return fixer.insertTextAfter(lastProp, `, "keywords": ["${REQUIRED_KEYWORD}"]`);
-						},
-					});
-					return;
-				}
-
-				if (keywordsProp.value.type !== AST_NODE_TYPES.ArrayExpression) {
-					return;
-				}
-
-				const keywordsArray = keywordsProp.value;
-				const hasRequiredKeyword = keywordsArray.elements.some(
-					(element) =>
-						element?.type === AST_NODE_TYPES.Literal && element.value === REQUIRED_KEYWORD,
-				);
-
-				if (!hasRequiredKeyword) {
-					context.report({
-						node: keywordsProp,
-						messageId: 'missingKeyword',
-						fix(fixer) {
-							const lastElement = keywordsArray.elements[keywordsArray.elements.length - 1];
-							if (!lastElement) {
-								return fixer.replaceText(keywordsArray, `["${REQUIRED_KEYWORD}"]`);
-							}
-							return fixer.insertTextAfter(lastElement, `, "${REQUIRED_KEYWORD}"`);
-						},
-					});
-				}
-			},
-		};
-	},
-});

package/src/rules/require-continue-on-fail.test.ts

@@ -1,129 +0,0 @@
-import { RuleTester } from '@typescript-eslint/rule-tester';
-
-import { RequireContinueOnFailRule } from './require-continue-on-fail.js';
-
-const ruleTester = new RuleTester();
-
-function createNodeWithExecute(executeBody: string): string {
-	return `
-import type { INodeType, INodeTypeDescription, IExecuteFunctions, INodeExecutionData } 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: ['main'],
-		outputs: ['main'],
-		properties: [],
-	};
-
-	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
-		${executeBody}
-	}
-}`;
-}
-
-ruleTester.run('require-continue-on-fail', RequireContinueOnFailRule, {
-	valid: [
-		{
-			name: 'node with continueOnFail in catch block',
-			code: createNodeWithExecute(`
-				const items = this.getInputData();
-				const returnData: INodeExecutionData[] = [];
-				for (let i = 0; i < items.length; i++) {
-					try {
-						returnData.push({ json: { result: true } });
-					} catch (error) {
-						if (this.continueOnFail()) {
-							returnData.push({ json: { error: error.message } });
-							continue;
-						}
-						throw error;
-					}
-				}
-				return [returnData];
-			`),
-		},
-		{
-			name: 'non-node class with execute method (should be ignored)',
-			code: `
-export class RegularClass {
-	async execute() {
-		return [[]];
-	}
-}`,
-		},
-		{
-			name: 'node class without execute method (should be ignored)',
-			code: `
-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: ['main'],
-		outputs: ['main'],
-		properties: [],
-	};
-}`,
-		},
-		{
-			name: 'node extending Node base class with continueOnFail',
-			code: `
-import { Node } from 'n8n-workflow';
-
-export class TestNode extends Node {
-	async execute() {
-		try {
-			// do work
-		} catch (error) {
-			if (this.continueOnFail()) {
-				return [[]];
-			}
-			throw error;
-		}
-		return [[]];
-	}
-}`,
-		},
-	],
-	invalid: [
-		{
-			name: 'node with execute but no continueOnFail',
-			code: createNodeWithExecute(`
-				const items = this.getInputData();
-				const returnData: INodeExecutionData[] = [];
-				for (let i = 0; i < items.length; i++) {
-					returnData.push({ json: { result: true } });
-				}
-				return [returnData];
-			`),
-			errors: [{ messageId: 'missingContinueOnFail' }],
-		},
-		{
-			name: 'node with try/catch but no continueOnFail check',
-			code: createNodeWithExecute(`
-				const items = this.getInputData();
-				const returnData: INodeExecutionData[] = [];
-				for (let i = 0; i < items.length; i++) {
-					try {
-						returnData.push({ json: { result: true } });
-					} catch (error) {
-						throw error;
-					}
-				}
-				return [returnData];
-			`),
-			errors: [{ messageId: 'missingContinueOnFail' }],
-		},
-	],
-});

package/src/rules/require-continue-on-fail.ts

@@ -1,88 +0,0 @@
-import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
-
-import { isNodeTypeClass } from '../utils/index.js';
-import { createRule } from '../utils/rule-creator.js';
-
-/** Keys that are not child AST nodes (back-references, metadata). */
-const NON_CHILD_KEYS = new Set(['parent', 'loc', 'range', 'start', 'end', 'tokens', 'comments']);
-
-/**
- * Recursively checks whether any descendant of the given AST node is a
- * `this.continueOnFail()` call expression.
- */
-function containsContinueOnFailCall(node: TSESTree.Node): boolean {
-	if (
-		node.type === AST_NODE_TYPES.CallExpression &&
-		node.callee.type === AST_NODE_TYPES.MemberExpression &&
-		node.callee.object.type === AST_NODE_TYPES.ThisExpression &&
-		node.callee.property.type === AST_NODE_TYPES.Identifier &&
-		node.callee.property.name === 'continueOnFail'
-	) {
-		return true;
-	}
-
-	for (const key of Object.keys(node)) {
-		if (NON_CHILD_KEYS.has(key)) continue;
-
-		const value = (node as unknown as Record<string, unknown>)[key];
-
-		if (Array.isArray(value)) {
-			for (const child of value) {
-				if (child && typeof child === 'object' && 'type' in child) {
-					if (containsContinueOnFailCall(child as TSESTree.Node)) {
-						return true;
-					}
-				}
-			}
-		} else if (value && typeof value === 'object' && 'type' in value) {
-			if (containsContinueOnFailCall(value as TSESTree.Node)) {
-				return true;
-			}
-		}
-	}
-
-	return false;
-}
-
-export const RequireContinueOnFailRule = createRule({
-	name: 'require-continue-on-fail',
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Require continueOnFail() handling in execute() methods of node classes',
-		},
-		messages: {
-			missingContinueOnFail:
-				'execute() method must handle this.continueOnFail() for proper error handling. ' +
-				'Wrap item processing in a try/catch and check this.continueOnFail() in the catch block.',
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		return {
-			ClassDeclaration(node) {
-				if (!isNodeTypeClass(node)) {
-					return;
-				}
-
-				for (const member of node.body.body) {
-					if (
-						member.type !== AST_NODE_TYPES.MethodDefinition ||
-						member.key.type !== AST_NODE_TYPES.Identifier ||
-						member.key.name !== 'execute'
-					) {
-						continue;
-					}
-
-					if (member.value.body && !containsContinueOnFailCall(member.value.body)) {
-						context.report({
-							node: member.key,
-							messageId: 'missingContinueOnFail',
-						});
-					}
-				}
-			},
-		};
-	},
-});

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

@@ -1,67 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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}"`);
-					},
-				});
-			},
-		};
-	},
-});