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

package/src/rules/node-class-description-name-camelcase.ts

@@ -1,114 +0,0 @@
-import { TSESTree } from '@typescript-eslint/utils';
-
-import {
-	isNodeTypeClass,
-	findClassProperty,
-	findObjectProperty,
-	getStringLiteralValue,
-	isFileType,
-	createRule,
-} from '../utils/index.js';
-
-// `description.name` must be camelCase: a lowercase letter followed by
-// letters/digits, with no separators.
-const CAMEL_CASE_PATTERN = /^[a-z][a-zA-Z0-9]*$/;
-
-/**
- * Converts an arbitrary node name to camelCase by splitting on any
- * non-alphanumeric separators, upper-casing the first character of each
- * subsequent segment, and lower-casing the very first character.
- * Examples: `My Node` -> `myNode`, `my-node` -> `myNode`, `GitHub` -> `gitHub`.
- */
-function toCamelCase(value: string): string {
-	const segments = value.split(/[^a-zA-Z0-9]+/).filter(Boolean);
-	if (segments.length === 0) {
-		return value;
-	}
-
-	const joined = segments
-		.map((segment, index) =>
-			index === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1),
-		)
-		.join('');
-
-	return joined.charAt(0).toLowerCase() + joined.slice(1);
-}
-
-// Serialize a value as a string literal using the original quote character,
-// escaping any characters that would otherwise break the literal so the
-// autofix never emits invalid code.
-function toStringLiteral(value: string, quote: string): string {
-	const escaped = value
-		.replace(/\\/g, '\\\\')
-		.replace(/\n/g, '\\n')
-		.replace(/\r/g, '\\r')
-		.split(quote)
-		.join(`\\${quote}`);
-	return `${quote}${escaped}${quote}`;
-}
-
-export const NodeClassDescriptionNameCamelCaseRule = createRule({
-	name: 'node-class-description-name-camelcase',
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Node class `description.name` must be camelCase',
-		},
-		messages: {
-			notCamelCase: "Node `description.name` '{{value}}' must be camelCase",
-		},
-		fixable: 'code',
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		if (!isFileType(context.filename, '.node.ts')) {
-			return {};
-		}
-
-		return {
-			ClassDeclaration(node) {
-				if (!isNodeTypeClass(node)) {
-					return;
-				}
-
-				const descriptionProperty = findClassProperty(node, 'description');
-				if (descriptionProperty?.value?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
-					return;
-				}
-
-				const nameProperty = findObjectProperty(descriptionProperty.value, 'name');
-				if (!nameProperty) {
-					return;
-				}
-
-				const nameValue = getStringLiteralValue(nameProperty.value);
-				if (nameValue === null) {
-					return;
-				}
-
-				if (CAMEL_CASE_PATTERN.test(nameValue)) {
-					return;
-				}
-
-				const valueNode = nameProperty.value;
-				const fixedValue = toCamelCase(nameValue);
-				// Only offer an autofix when it actually yields a valid camelCase
-				// value (e.g. names starting with a digit cannot be repaired).
-				const canFix = fixedValue !== nameValue && CAMEL_CASE_PATTERN.test(fixedValue);
-
-				context.report({
-					node: valueNode,
-					messageId: 'notCamelCase',
-					data: { value: nameValue },
-					fix: canFix
-						? (fixer) => {
-								const quote = context.sourceCode.getText(valueNode).charAt(0);
-								return fixer.replaceText(valueNode, toStringLiteral(fixedValue, quote));
-							}
-						: undefined,
-				});
-			},
-		};
-	},
-});

package/src/rules/node-filename-against-convention.test.ts

@@ -1,115 +0,0 @@
-import { RuleTester } from '@typescript-eslint/rule-tester';
-
-import { NodeFilenameAgainstConventionRule } from './node-filename-against-convention.js';
-
-const ruleTester = new RuleTester();
-
-function createNodeCode(name: string): string {
-	return `
-import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
-
-export class TestNode implements INodeType {
-	description: INodeTypeDescription = {
-		displayName: 'Test Node',
-		name: '${name}',
-		group: ['input'],
-		version: 1,
-		description: 'A test node',
-		defaults: { name: 'Test Node' },
-		inputs: [],
-		outputs: [],
-		properties: [],
-	};
-}`;
-}
-
-function createNodeCodeWithoutName(): string {
-	return `
-import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
-
-export class TestNode implements INodeType {
-	description: INodeTypeDescription = {
-		displayName: 'Test Node',
-		group: ['input'],
-		version: 1,
-		description: 'A test node',
-		defaults: { name: 'Test Node' },
-		inputs: [],
-		outputs: [],
-		properties: [],
-	};
-}`;
-}
-
-function createRegularClass(): string {
-	return `
-export class SomeHelper {
-	name = 'github';
-}`;
-}
-
-ruleTester.run('node-filename-against-convention', NodeFilenameAgainstConventionRule, {
-	valid: [
-		{
-			name: 'filename matches PascalCased description.name',
-			filename: '/tmp/Github.node.ts',
-			code: createNodeCode('github'),
-		},
-		{
-			name: 'filename with version suffix is accepted',
-			filename: '/tmp/GithubV2.node.ts',
-			code: createNodeCode('github'),
-		},
-		{
-			name: 'filename with multi-digit version suffix is accepted',
-			filename: '/tmp/GithubV10.node.ts',
-			code: createNodeCode('github'),
-		},
-		{
-			name: 'multi-word camelCase name maps to PascalCase filename',
-			filename: '/tmp/GoogleSheets.node.ts',
-			code: createNodeCode('googleSheets'),
-		},
-		{
-			name: 'class not implementing INodeType is ignored',
-			filename: '/tmp/Github.node.ts',
-			code: createRegularClass(),
-		},
-		{
-			name: 'non-.node.ts file is ignored',
-			filename: '/tmp/Github.ts',
-			code: createNodeCode('mismatch'),
-		},
-		{
-			name: 'missing description.name is ignored',
-			filename: '/tmp/Github.node.ts',
-			code: createNodeCodeWithoutName(),
-		},
-	],
-	invalid: [
-		{
-			name: 'filename does not match description.name',
-			filename: '/tmp/Github.node.ts',
-			code: createNodeCode('gitlab'),
-			errors: [{ messageId: 'renameFile', data: { expected: 'Gitlab.node.ts' } }],
-		},
-		{
-			name: 'filename is lowercased',
-			filename: '/tmp/github.node.ts',
-			code: createNodeCode('github'),
-			errors: [{ messageId: 'renameFile', data: { expected: 'Github.node.ts' } }],
-		},
-		{
-			name: 'filename has wrong internal casing',
-			filename: '/tmp/GitHub.node.ts',
-			code: createNodeCode('github'),
-			errors: [{ messageId: 'renameFile', data: { expected: 'Github.node.ts' } }],
-		},
-		{
-			name: 'version suffix does not excuse a mismatched base name',
-			filename: '/tmp/GitlabV2.node.ts',
-			code: createNodeCode('github'),
-			errors: [{ messageId: 'renameFile', data: { expected: 'Github.node.ts' } }],
-		},
-	],
-});

package/src/rules/node-filename-against-convention.ts

@@ -1,76 +0,0 @@
-import { TSESTree } from '@typescript-eslint/utils';
-import * as path from 'node:path';
-
-import {
-	isNodeTypeClass,
-	findClassProperty,
-	findObjectProperty,
-	getStringLiteralValue,
-	isFileType,
-	createRule,
-} from '../utils/index.js';
-
-/**
- * Converts a `description.name` to the expected node file basename by
- * upper-casing the first character. The source of truth is `description.name`,
- * not the class name. Example: `github` -> `Github`.
- */
-function toExpectedBaseName(name: string): string {
-	return name.charAt(0).toUpperCase() + name.slice(1);
-}
-
-export const NodeFilenameAgainstConventionRule = createRule({
-	name: 'node-filename-against-convention',
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Node filename must match the node `description.name`',
-		},
-		messages: {
-			renameFile: 'Node filename must match `description.name`. Rename file to "{{expected}}".',
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		if (!isFileType(context.filename, '.node.ts')) {
-			return {};
-		}
-
-		return {
-			ClassDeclaration(node) {
-				if (!isNodeTypeClass(node)) {
-					return;
-				}
-
-				const descriptionProperty = findClassProperty(node, 'description');
-				if (descriptionProperty?.value?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
-					return;
-				}
-
-				const nameProperty = findObjectProperty(descriptionProperty.value, 'name');
-				if (!nameProperty) {
-					return;
-				}
-
-				const name = getStringLiteralValue(nameProperty.value);
-				if (!name) {
-					return;
-				}
-
-				const expectedBaseName = toExpectedBaseName(name);
-				// Strip the `.node.ts` extension and any trailing `V<digits>` version
-				// suffix so versioned files (e.g. `GithubV2.node.ts`) are accepted.
-				const actualBaseName = path.basename(context.filename, '.node.ts').replace(/V\d+$/, '');
-
-				if (actualBaseName !== expectedBaseName) {
-					context.report({
-						node: nameProperty.value,
-						messageId: 'renameFile',
-						data: { expected: `${expectedBaseName}.node.ts` },
-					});
-				}
-			},
-		};
-	},
-});

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

@@ -1,280 +0,0 @@
-import { RuleTester } from '@typescript-eslint/rule-tester';
-
-import { NodeOperationErrorItemIndexRule } from './node-operation-error-itemindex.js';
-
-const ruleTester = new RuleTester();
-
-const NODE_FILENAME = 'TestNode.node.ts';
-
-function createNodeWithExecute(executeBody: string): { filename: string; code: string } {
-	return {
-		filename: NODE_FILENAME,
-		code: `
-import type { INodeType, INodeTypeDescription, IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
-import { NodeOperationError, NodeApiError } 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('node-operation-error-itemindex', NodeOperationErrorItemIndexRule, {
-	valid: [
-		{
-			name: 'non-node class is ignored',
-			filename: NODE_FILENAME,
-			code: `
-export class RegularClass {
-	async execute() {
-		const items = this.getInputData();
-		for (let i = 0; i < items.length; i++) {
-			throw new NodeOperationError(this.getNode(), 'error');
-		}
-	}
-}`,
-		},
-		{
-			name: 'NodeOperationError outside any loop is allowed',
-			...createNodeWithExecute(`
-				throw new NodeOperationError(this.getNode(), 'some error');
-			`),
-		},
-		{
-			name: 'NodeOperationError in a non-item loop is allowed',
-			...createNodeWithExecute(`
-				const settings = ['a', 'b', 'c'];
-				for (let i = 0; i < settings.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error');
-				}
-			`),
-		},
-		{
-			name: 'NodeOperationError with itemIndex in C-style for loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error', { itemIndex: i });
-				}
-			`),
-		},
-		{
-			name: 'NodeOperationError with itemIndex shorthand in C-style for loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-					throw new NodeOperationError(this.getNode(), 'error', { itemIndex });
-				}
-			`),
-		},
-		{
-			name: 'NodeApiError with itemIndex in C-style for loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeApiError(this.getNode(), error, { itemIndex: i });
-				}
-			`),
-		},
-		{
-			name: 'NodeOperationError with itemIndex in for...of loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (const [i, item] of items.entries()) {
-					throw new NodeOperationError(this.getNode(), 'error', { itemIndex: i });
-				}
-			`),
-		},
-		{
-			name: 'NodeOperationError with itemIndex in for...of directly over getInputData()',
-			...createNodeWithExecute(`
-				let i = 0;
-				for (const item of this.getInputData()) {
-					throw new NodeOperationError(this.getNode(), 'error', { itemIndex: i++ });
-				}
-			`),
-		},
-		{
-			name: 'NodeOperationError with variable as 3rd arg (cannot statically verify — skip)',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					const opts = { itemIndex: i };
-					throw new NodeOperationError(this.getNode(), 'error', opts);
-				}
-			`),
-		},
-		{
-			name: 'NodeOperationError with spread plus explicit itemIndex in options',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error', { ...opts, itemIndex: i });
-				}
-			`),
-		},
-		{
-			name: 'NodeOperationError outside execute() method is not flagged',
-			filename: NODE_FILENAME,
-			code: `
-import type { INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from 'n8n-workflow';
-import { NodeOperationError } from 'n8n-workflow';
-
-export class TestNode implements INodeType {
-	description: INodeTypeDescription = {
-		displayName: 'Test Node',
-		name: 'testNode',
-		group: ['trigger'],
-		version: 1,
-		description: 'A test node',
-		defaults: { name: 'Test Node' },
-		inputs: [],
-		outputs: ['main'],
-		webhooks: [{ name: 'default', httpMethod: 'POST', responseMode: 'onReceived', path: 'webhook' }],
-		properties: [],
-	};
-
-	async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
-		const items = this.getInputData();
-		for (let i = 0; i < items.length; i++) {
-			throw new NodeOperationError(this.getNode(), 'webhook error');
-		}
-		return { workflowData: [[]] };
-	}
-}`,
-		},
-		{
-			name: 'NodeOperationError in nested non-item for loop inside item loop is allowed',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					const options = ['a', 'b'];
-					for (let j = 0; j < options.length; j++) {
-						throw new NodeOperationError(this.getNode(), 'error', { itemIndex: i });
-					}
-				}
-			`),
-		},
-	],
-	invalid: [
-		{
-			name: 'NodeOperationError without any options in C-style for loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error');
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-		{
-			name: 'NodeOperationError with empty options object in C-style for loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error', {});
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-		{
-			name: 'NodeOperationError with options but missing itemIndex in C-style for loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error', { description: 'something' });
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-		{
-			name: 'NodeApiError without itemIndex in C-style for loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeApiError(this.getNode(), error);
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeApiError' } }],
-		},
-		{
-			name: 'NodeOperationError without itemIndex in for...of over items variable',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (const item of items) {
-					throw new NodeOperationError(this.getNode(), 'error');
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-		{
-			name: 'NodeOperationError without itemIndex in for...of directly over getInputData()',
-			...createNodeWithExecute(`
-				for (const item of this.getInputData()) {
-					throw new NodeOperationError(this.getNode(), 'error');
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-		{
-			name: 'multiple errors in the same item loop',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					if (someCondition) {
-						throw new NodeOperationError(this.getNode(), 'error A');
-					}
-					throw new NodeApiError(this.getNode(), error);
-				}
-			`),
-			errors: [
-				{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } },
-				{ messageId: 'missingItemIndex', data: { errorClass: 'NodeApiError' } },
-			],
-		},
-		{
-			name: 'NodeOperationError without itemIndex when loop variable is named itemIndex',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-					throw new NodeOperationError(this.getNode(), 'error', { description: 'oops' });
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-		{
-			name: 'NodeOperationError with spread-only options (spread does not guarantee itemIndex)',
-			...createNodeWithExecute(`
-				const items = this.getInputData();
-				for (let i = 0; i < items.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error', { ...opts });
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-		{
-			name: 'NodeOperationError without itemIndex with non-standard items variable name',
-			...createNodeWithExecute(`
-				const inputItems = this.getInputData();
-				for (let i = 0; i < inputItems.length; i++) {
-					throw new NodeOperationError(this.getNode(), 'error');
-				}
-			`),
-			errors: [{ messageId: 'missingItemIndex', data: { errorClass: 'NodeOperationError' } }],
-		},
-	],
-});