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

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

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

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