@n8n/eslint-plugin-community-nodes 0.11.0 → 0.12.0

package/src/rules/no-forbidden-lifecycle-scripts.test.ts

@@ -0,0 +1,103 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { NoForbiddenLifecycleScriptsRule } from './no-forbidden-lifecycle-scripts.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-forbidden-lifecycle-scripts', NoForbiddenLifecycleScriptsRule, {
+	valid: [
+		{
+			name: 'no scripts field',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+		},
+		{
+			name: 'only safe scripts',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "build": "tsc", "test": "jest", "dev": "nodemon" } }',
+		},
+		{
+			name: 'non-package.json file is ignored',
+			filename: 'some-config.json',
+			code: '{ "scripts": { "prepare": "npm run build" } }',
+		},
+		{
+			name: 'empty scripts object',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": {} }',
+		},
+	],
+	invalid: [
+		{
+			name: 'prepare script is forbidden',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "prepare": "npm run build" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'prepare' } }],
+		},
+		{
+			name: 'preinstall script is forbidden',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "preinstall": "node setup.js" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'preinstall' } }],
+		},
+		{
+			name: 'install script is forbidden',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "install": "node install.js" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'install' } }],
+		},
+		{
+			name: 'postinstall script is forbidden',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "postinstall": "node setup.js" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'postinstall' } }],
+		},
+		{
+			name: 'prepublish script is forbidden',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "prepublish": "npm run build" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'prepublish' } }],
+		},
+		{
+			name: 'preprepare script is forbidden',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "preprepare": "echo prep" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'preprepare' } }],
+		},
+		{
+			name: 'postprepare script is forbidden',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "postprepare": "echo done" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'postprepare' } }],
+		},
+		{
+			name: 'multiple forbidden scripts report separate errors',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "prepare": "npm run build", "postinstall": "node setup.js" } }',
+			errors: [
+				{ messageId: 'forbiddenScript', data: { scriptName: 'prepare' } },
+				{ messageId: 'forbiddenScript', data: { scriptName: 'postinstall' } },
+			],
+		},
+		{
+			name: 'mix of allowed and forbidden scripts — only forbidden reported',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "build": "tsc", "prepare": "npm run build", "test": "jest" } }',
+			errors: [{ messageId: 'forbiddenScript', data: { scriptName: 'prepare' } }],
+		},
+		{
+			name: 'all seven forbidden scripts present',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "scripts": { "prepare": "a", "preinstall": "b", "install": "c", "postinstall": "d", "prepublish": "e", "preprepare": "f", "postprepare": "g" } }',
+			errors: [
+				{ messageId: 'forbiddenScript', data: { scriptName: 'prepare' } },
+				{ messageId: 'forbiddenScript', data: { scriptName: 'preinstall' } },
+				{ messageId: 'forbiddenScript', data: { scriptName: 'install' } },
+				{ messageId: 'forbiddenScript', data: { scriptName: 'postinstall' } },
+				{ messageId: 'forbiddenScript', data: { scriptName: 'prepublish' } },
+				{ messageId: 'forbiddenScript', data: { scriptName: 'preprepare' } },
+				{ messageId: 'forbiddenScript', data: { scriptName: 'postprepare' } },
+			],
+		},
+	],
+});

package/src/rules/no-forbidden-lifecycle-scripts.ts

@@ -0,0 +1,69 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import { createRule, findJsonProperty } from '../utils/index.js';
+
+const FORBIDDEN_SCRIPTS = [
+	'prepare',
+	'preinstall',
+	'install',
+	'postinstall',
+	'prepublish',
+	'preprepare',
+	'postprepare',
+];
+
+export const NoForbiddenLifecycleScriptsRule = createRule({
+	name: 'no-forbidden-lifecycle-scripts',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Ban lifecycle scripts (prepare, preinstall, postinstall, etc.) in community node packages',
+		},
+		messages: {
+			forbiddenScript:
+				'Lifecycle script "{{ scriptName }}" is not allowed in community node packages. These scripts execute arbitrary code during installation.',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!context.filename.endsWith('package.json')) {
+			return {};
+		}
+
+		return {
+			ObjectExpression(node: TSESTree.ObjectExpression) {
+				// Only process the root object, not nested ones
+				if (node.parent?.type === AST_NODE_TYPES.Property) {
+					return;
+				}
+
+				const scriptsProp = findJsonProperty(node, 'scripts');
+				if (!scriptsProp || scriptsProp.value.type !== AST_NODE_TYPES.ObjectExpression) {
+					return;
+				}
+
+				for (const property of scriptsProp.value.properties) {
+					if (property.type !== AST_NODE_TYPES.Property) continue;
+
+					const key =
+						property.key.type === AST_NODE_TYPES.Identifier
+							? property.key.name
+							: property.key.type === AST_NODE_TYPES.Literal
+								? String(property.key.value)
+								: null;
+
+					if (key !== null && FORBIDDEN_SCRIPTS.includes(key)) {
+						context.report({
+							node: property,
+							messageId: 'forbiddenScript',
+							data: { scriptName: key },
+						});
+					}
+				}
+			},
+		};
+	},
+});

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

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

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