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

package/src/rules/node-operation-error-itemindex.ts

@@ -1,223 +0,0 @@
-/**
- * Flags `new NodeOperationError(...)` or `new NodeApiError(...)` inside item
- * loops in `execute()` methods that omit `{ itemIndex }` from the options
- * argument. Without it, n8n cannot associate the error with the specific item
- * that caused it, breaking per-item error reporting and `continueOnFail`.
- *
- * "Item loop" means a `for` or `for...of` that iterates over the result of
- * `this.getInputData()` (or a variable initialised from it). Errors outside
- * such loops — e.g. in webhook handlers or trigger setup — are not flagged.
- */
-
-import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
-
-import { createRule, findObjectProperty, isFileType, isNodeTypeClass } from '../utils/index.js';
-
-const ITEM_ERROR_CLASSES = new Set(['NodeOperationError', 'NodeApiError']);
-
-/** Returns true when `node` is a bare `this.getInputData(...)` call. */
-function isGetInputDataCall(node: TSESTree.CallExpression): boolean {
-	return (
-		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 === 'getInputData'
-	);
-}
-
-/** Returns true when `node` is `<varName>.length` for any name in `varNames`. */
-function isLengthAccessOnVariable(node: TSESTree.Node, varNames: Set<string>): boolean {
-	return (
-		node.type === AST_NODE_TYPES.MemberExpression &&
-		!node.computed &&
-		node.property.type === AST_NODE_TYPES.Identifier &&
-		node.property.name === 'length' &&
-		node.object.type === AST_NODE_TYPES.Identifier &&
-		varNames.has(node.object.name)
-	);
-}
-
-/**
- * Returns true when the `for` test condition references `<itemVar>.length`,
- * indicating that the loop iterates over an items array.
- */
-function isItemForLoop(node: TSESTree.ForStatement, itemVarNames: Set<string>): boolean {
-	if (!node.test || node.test.type !== AST_NODE_TYPES.BinaryExpression) return false;
-
-	const { left, right } = node.test;
-	return (
-		isLengthAccessOnVariable(left, itemVarNames) || isLengthAccessOnVariable(right, itemVarNames)
-	);
-}
-
-/**
- * Returns true when the `for...of` iterable is an items variable or a direct
- * `this.getInputData()` call.
- */
-function isItemForOfLoop(node: TSESTree.ForOfStatement, itemVarNames: Set<string>): boolean {
-	const { right } = node;
-
-	if (right.type === AST_NODE_TYPES.Identifier && itemVarNames.has(right.name)) {
-		return true;
-	}
-
-	return right.type === AST_NODE_TYPES.CallExpression && isGetInputDataCall(right);
-}
-
-/**
- * Returns true when the `NodeOperationError` / `NodeApiError` constructor call
- * already has an `{ itemIndex }` property in its options argument, or when the
- * options argument cannot be statically inspected (variable / spread) — in
- * which case we give the benefit of the doubt.
- */
-function hasItemIndexOption(node: TSESTree.NewExpression): boolean {
-	const { arguments: args } = node;
-
-	if (args.length < 3) return false;
-
-	const optionsArg = args[2];
-
-	// Non-object-literal (bare variable reference) — can't statically check, assume OK.
-	if (!optionsArg || optionsArg.type !== AST_NODE_TYPES.ObjectExpression) {
-		return true;
-	}
-
-	// itemIndex must be an explicit own property of the options object.
-	// Spread elements (e.g. { ...opts }) are not sufficient — they may not
-	// include itemIndex and would silently bypass this requirement.
-	return findObjectProperty(optionsArg, 'itemIndex') !== null;
-}
-
-export const NodeOperationErrorItemIndexRule = createRule({
-	name: 'node-operation-error-itemindex',
-	meta: {
-		type: 'problem',
-		docs: {
-			description:
-				'Require { itemIndex } in NodeOperationError / NodeApiError options inside item loops',
-		},
-		messages: {
-			missingItemIndex:
-				'`new {{ errorClass }}(...)` inside an item loop must include `{ itemIndex }` as the ' +
-				'third argument so n8n can associate the error with the failing item.',
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		if (!isFileType(context.filename, '.node.ts')) {
-			return {};
-		}
-
-		let inNodeTypeClass = false;
-		let inExecuteMethod = false;
-
-		/** Names of variables initialised from `this.getInputData()` in the current execute() scope. */
-		const itemVariableNames = new Set<string>();
-
-		/** AST nodes for loops that are confirmed item loops. */
-		const itemLoopNodes = new Set<TSESTree.ForStatement | TSESTree.ForOfStatement>();
-
-		/** Number of currently open item loops (supports nested loops). */
-		let itemLoopDepth = 0;
-
-		function resetExecuteState() {
-			inExecuteMethod = false;
-			itemVariableNames.clear();
-			itemLoopNodes.clear();
-			itemLoopDepth = 0;
-		}
-
-		return {
-			ClassDeclaration(node) {
-				if (isNodeTypeClass(node)) {
-					inNodeTypeClass = true;
-				}
-			},
-
-			'ClassDeclaration:exit'() {
-				inNodeTypeClass = false;
-				resetExecuteState();
-			},
-
-			MethodDefinition(node: TSESTree.MethodDefinition) {
-				if (
-					inNodeTypeClass &&
-					node.key.type === AST_NODE_TYPES.Identifier &&
-					node.key.name === 'execute'
-				) {
-					inExecuteMethod = true;
-				}
-			},
-
-			'MethodDefinition:exit'(node: TSESTree.MethodDefinition) {
-				if (
-					inExecuteMethod &&
-					node.key.type === AST_NODE_TYPES.Identifier &&
-					node.key.name === 'execute'
-				) {
-					resetExecuteState();
-				}
-			},
-
-			VariableDeclarator(node: TSESTree.VariableDeclarator) {
-				if (!inExecuteMethod) return;
-				if (!node.init) return;
-				if (node.id.type !== AST_NODE_TYPES.Identifier) return;
-
-				if (node.init.type === AST_NODE_TYPES.CallExpression && isGetInputDataCall(node.init)) {
-					itemVariableNames.add(node.id.name);
-				}
-			},
-
-			ForStatement(node: TSESTree.ForStatement) {
-				if (!inExecuteMethod) return;
-				if (isItemForLoop(node, itemVariableNames)) {
-					itemLoopNodes.add(node);
-					itemLoopDepth++;
-				}
-			},
-
-			'ForStatement:exit'(node: TSESTree.ForStatement) {
-				if (itemLoopNodes.has(node)) {
-					itemLoopNodes.delete(node);
-					itemLoopDepth--;
-				}
-			},
-
-			ForOfStatement(node: TSESTree.ForOfStatement) {
-				if (!inExecuteMethod) return;
-				if (isItemForOfLoop(node, itemVariableNames)) {
-					itemLoopNodes.add(node);
-					itemLoopDepth++;
-				}
-			},
-
-			'ForOfStatement:exit'(node: TSESTree.ForOfStatement) {
-				if (itemLoopNodes.has(node)) {
-					itemLoopNodes.delete(node);
-					itemLoopDepth--;
-				}
-			},
-
-			NewExpression(node: TSESTree.NewExpression) {
-				if (itemLoopDepth === 0) return;
-
-				if (
-					node.callee.type !== AST_NODE_TYPES.Identifier ||
-					!ITEM_ERROR_CLASSES.has(node.callee.name)
-				) {
-					return;
-				}
-
-				if (!hasItemIndexOption(node)) {
-					context.report({
-						node,
-						messageId: 'missingItemIndex',
-						data: { errorClass: node.callee.name },
-					});
-				}
-			},
-		};
-	},
-});

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

@@ -1,468 +0,0 @@
-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' },
-				},
-			],
-		},
-	],
-});