@atom8n/eslint-plugin-community-nodes 0.7.0

package/src/rules/no-restricted-imports.test.ts

@@ -0,0 +1,182 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { NoRestrictedImportsRule } from './no-restricted-imports.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-restricted-imports', NoRestrictedImportsRule, {
+	valid: [
+		{
+			code: 'import { WorkflowExecuteMode } from "n8n-workflow";',
+		},
+		{
+			code: 'import _ from "lodash";',
+		},
+		{
+			code: 'import moment from "moment";',
+		},
+		{
+			code: 'import pLimit from "p-limit";',
+		},
+		{
+			code: 'import { DateTime } from "luxon";',
+		},
+		{
+			code: 'import { z } from "zod";',
+		},
+		{
+			code: 'import crypto from "crypto";',
+		},
+		{
+			code: 'import crypto from "node:crypto";',
+		},
+		{
+			code: 'import { helper } from "./helper";',
+		},
+		{
+			code: 'import { utils } from "../utils";',
+		},
+		{
+			code: 'const helper = require("./helper");',
+		},
+		{
+			code: 'const utils = require("../utils");',
+		},
+		{
+			code: 'const _ = require("lodash");',
+		},
+		{
+			code: 'require.resolve("lodash");',
+		},
+		{
+			code: 'require.resolve("./helper");',
+		},
+		{
+			code: 'require.resolve("../utils");',
+		},
+		{
+			code: 'const workflow = await import("n8n-workflow");',
+		},
+		{
+			code: 'import("lodash").then((_) => {});',
+		},
+		{
+			code: 'const helper = await import("./helper");',
+		},
+		{
+			code: 'import("../utils").then((utils) => {});',
+		},
+		{
+			code: 'import(`lodash`).then((_) => {});',
+		},
+		{
+			code: 'require(`./helper`);',
+		},
+		{
+			code: 'require.resolve(`n8n-workflow`);',
+		},
+		{
+			code: 'const workflow = await import(`n8n-workflow`);',
+		},
+	],
+	invalid: [
+		{
+			code: 'import fs from "fs";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'import path from "path";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'import express from "express";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'import axios from "axios";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: 'axios' } }],
+		},
+		{
+			code: 'import { Client } from "@elastic/elasticsearch";',
+			errors: [{ messageId: 'restrictedImport', data: { modulePath: '@elastic/elasticsearch' } }],
+		},
+		{
+			code: 'const fs = require("fs");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'const path = require("path");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'const express = require("express");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'require.resolve("fs");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'require.resolve("express");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'const resolved = require.resolve("axios");',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'axios' } }],
+		},
+		{
+			code: `
+import fs from "fs";
+import path from "path";
+import { WorkflowExecuteMode } from "n8n-workflow";`,
+			errors: [
+				{ messageId: 'restrictedImport', data: { modulePath: 'fs' } },
+				{ messageId: 'restrictedImport', data: { modulePath: 'path' } },
+			],
+		},
+		{
+			code: `
+const fs = require("fs");
+const express = require("express");
+const lodash = require("lodash");`,
+			errors: [
+				{ messageId: 'restrictedRequire', data: { modulePath: 'fs' } },
+				{ messageId: 'restrictedRequire', data: { modulePath: 'express' } },
+			],
+		},
+		{
+			code: 'const fs = await import("fs");',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'fs' } }],
+		},
+		{
+			code: 'import("path").then((path) => {});',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'const express = await import("express");',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'const path = require(`path`);',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'path' } }],
+		},
+		{
+			code: 'require.resolve(`express`);',
+			errors: [{ messageId: 'restrictedRequire', data: { modulePath: 'express' } }],
+		},
+		{
+			code: 'const axios = await import(`axios`);',
+			errors: [{ messageId: 'restrictedDynamicImport', data: { modulePath: 'axios' } }],
+		},
+		{
+			code: `
+const fs = await import("fs");
+import("axios").then((axios) => {});
+const workflow = await import("n8n-workflow");`,
+			errors: [
+				{ messageId: 'restrictedDynamicImport', data: { modulePath: 'fs' } },
+				{ messageId: 'restrictedDynamicImport', data: { modulePath: 'axios' } },
+			],
+		},
+	],
+});

package/src/rules/no-restricted-imports.ts

@@ -0,0 +1,91 @@
+import {
+	getModulePath,
+	isDirectRequireCall,
+	isRequireMemberCall,
+	createRule,
+} from '../utils/index.js';
+
+const allowedModules = [
+	'n8n-workflow',
+	'lodash',
+	'moment',
+	'p-limit',
+	'luxon',
+	'zod',
+	'crypto',
+	'node:crypto',
+];
+
+const isModuleAllowed = (modulePath: string): boolean => {
+	if (modulePath.startsWith('./') || modulePath.startsWith('../')) return true;
+
+	const moduleName = modulePath.startsWith('@')
+		? modulePath.split('/').slice(0, 2).join('/')
+		: modulePath.split('/')[0];
+	if (!moduleName) return true;
+	return allowedModules.includes(moduleName);
+};
+
+export const NoRestrictedImportsRule = createRule({
+	name: 'no-restricted-imports',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow usage of restricted imports in community nodes.',
+		},
+		messages: {
+			restrictedImport:
+				"Import of '{{ modulePath }}' is not allowed. n8n Cloud does not allow community nodes with dependencies.",
+			restrictedRequire:
+				"Require of '{{ modulePath }}' is not allowed. n8n Cloud does not allow community nodes with dependencies.",
+			restrictedDynamicImport:
+				"Dynamic import of '{{ modulePath }}' is not allowed. n8n Cloud does not allow community nodes with dependencies.",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			ImportDeclaration(node) {
+				const modulePath = getModulePath(node.source);
+				if (modulePath && !isModuleAllowed(modulePath)) {
+					context.report({
+						node,
+						messageId: 'restrictedImport',
+						data: {
+							modulePath,
+						},
+					});
+				}
+			},
+
+			ImportExpression(node) {
+				const modulePath = getModulePath(node.source);
+				if (modulePath && !isModuleAllowed(modulePath)) {
+					context.report({
+						node,
+						messageId: 'restrictedDynamicImport',
+						data: {
+							modulePath,
+						},
+					});
+				}
+			},
+
+			CallExpression(node) {
+				if (isDirectRequireCall(node) || isRequireMemberCall(node)) {
+					const modulePath = getModulePath(node.arguments[0] ?? null);
+					if (modulePath && !isModuleAllowed(modulePath)) {
+						context.report({
+							node,
+							messageId: 'restrictedRequire',
+							data: {
+								modulePath,
+							},
+						});
+					}
+				}
+			},
+		};
+	},
+});

package/src/rules/node-usable-as-tool.test.ts

@@ -0,0 +1,81 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { NodeUsableAsToolRule } from './node-usable-as-tool.js';
+
+const ruleTester = new RuleTester();
+
+function createNodeCode(
+	usableAsTool?: boolean | 'missing',
+	hasDescription: boolean = true,
+): string {
+	let usableAsToolProperty = '';
+	if (usableAsTool === true) {
+		usableAsToolProperty = ',\n\t\tusableAsTool: true';
+	} else if (usableAsTool === false) {
+		usableAsToolProperty = ',\n\t\tusableAsTool: false';
+	}
+
+	if (!hasDescription) {
+		return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	displayName = 'Test Node';
+}`;
+	}
+
+	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: ['main'],
+		outputs: ['main'],
+		properties: []${usableAsToolProperty},
+	};
+}`;
+}
+
+function createNonNodeClass(): string {
+	return `
+export class RegularClass {
+	someProperty = 'value';
+}`;
+}
+
+ruleTester.run('node-usable-as-tool', NodeUsableAsToolRule, {
+	valid: [
+		{
+			name: 'node with usableAsTool set to true',
+			code: createNodeCode(true),
+		},
+		{
+			name: 'class that does not implement INodeType',
+			code: createNonNodeClass(),
+		},
+		{
+			name: 'node with usableAsTool set to false',
+			code: createNodeCode(false),
+		},
+		{
+			name: 'node without description property',
+			code: createNodeCode(undefined, false),
+		},
+	],
+	invalid: [
+		{
+			name: 'node missing usableAsTool property',
+			code: createNodeCode('missing'),
+			errors: [{ messageId: 'missingUsableAsTool' }],
+			output: createNodeCode(true),
+		},
+	],
+});

package/src/rules/node-usable-as-tool.ts

@@ -0,0 +1,72 @@
+import { TSESTree } from '@typescript-eslint/types';
+
+import {
+	isNodeTypeClass,
+	findClassProperty,
+	findObjectProperty,
+	createRule,
+} from '../utils/index.js';
+
+export const NodeUsableAsToolRule = createRule({
+	name: 'node-usable-as-tool',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Ensure node classes have usableAsTool property',
+		},
+		messages: {
+			missingUsableAsTool:
+				'Node class should have usableAsTool property. When in doubt, set it to true.',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) {
+					return;
+				}
+
+				const descriptionProperty = findClassProperty(node, 'description');
+				if (!descriptionProperty) {
+					return;
+				}
+
+				const descriptionValue = descriptionProperty.value;
+				if (descriptionValue?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
+					return;
+				}
+
+				const usableAsToolProperty = findObjectProperty(descriptionValue, 'usableAsTool');
+
+				if (!usableAsToolProperty) {
+					context.report({
+						node,
+						messageId: 'missingUsableAsTool',
+						fix(fixer) {
+							if (descriptionValue?.type === TSESTree.AST_NODE_TYPES.ObjectExpression) {
+								const properties = descriptionValue.properties;
+								if (properties.length === 0) {
+									const openBrace = descriptionValue.range[0] + 1;
+									return fixer.insertTextAfterRange(
+										[openBrace, openBrace],
+										'\n\t\tusableAsTool: true,',
+									);
+								} else {
+									const lastProperty = properties.at(-1);
+									if (lastProperty) {
+										return fixer.insertTextAfter(lastProperty, ',\n\t\tusableAsTool: true');
+									}
+								}
+							}
+
+							return null;
+						},
+					});
+				}
+			},
+		};
+	},
+});

package/src/rules/package-name-convention.test.ts

@@ -0,0 +1,189 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { PackageNameConventionRule } from './package-name-convention.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('package-name-convention', PackageNameConventionRule, {
+	valid: [
+		{
+			name: 'valid unscoped package name',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+		},
+		{
+			name: 'valid unscoped package name with dashes',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-my-service", "version": "1.0.0" }',
+		},
+		{
+			name: 'valid scoped package name',
+			filename: 'package.json',
+			code: '{ "name": "@mycompany/n8n-nodes-example", "version": "1.0.0" }',
+		},
+		{
+			name: 'valid scoped package name with dashes',
+			filename: 'package.json',
+			code: '{ "name": "@author/n8n-nodes-service", "version": "1.0.0" }',
+		},
+		{
+			name: 'object without name property',
+			filename: 'package.json',
+			code: '{ "version": "1.0.0", "description": "test" }',
+		},
+		{
+			name: 'non-package.json file ignored',
+			filename: 'some-config.json',
+			code: '{ "name": "my-config", "type": "config" }',
+		},
+		{
+			name: 'nested name fields should be ignored - only top-level name matters',
+			filename: 'package.json',
+			code: `{
+				"name": "n8n-nodes-example",
+				"version": "1.0.0",
+				"dependencies": {
+					"name": "invalid-nested-name"
+				},
+				"scripts": {
+					"name": "another-invalid-name"
+				},
+				"author": {
+					"name": "John Doe"
+				}
+			}`,
+		},
+		{
+			name: 'deeply nested name fields should be ignored',
+			filename: 'package.json',
+			code: `{
+				"name": "@author/n8n-nodes-service",
+				"version": "1.0.0",
+				"config": {
+					"nested": {
+						"deeply": {
+							"name": "very-invalid-name"
+						}
+					}
+				},
+				"repository": {
+					"type": "git",
+					"url": "https://github.com/user/repo",
+					"directory": {
+						"name": "bad-name"
+					}
+				}
+			}`,
+		},
+	],
+	invalid: [
+		{
+			name: 'invalid package name - generic',
+			filename: 'package.json',
+			code: '{ "name": "my-package", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'my-package' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: 'n8n-nodes-my-package' },
+							output: '{ "name": "n8n-nodes-my-package", "version": "1.0.0" }',
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'invalid package name - missing nodes',
+			filename: 'package.json',
+			code: '{ "name": "n8n-example", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'n8n-example' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: 'n8n-nodes-example' },
+							output: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'invalid scoped package name',
+			filename: 'package.json',
+			code: '{ "name": "@company/example-nodes", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: '@company/example-nodes' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: '@company/n8n-nodes-example' },
+							output: '{ "name": "@company/n8n-nodes-example", "version": "1.0.0" }',
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'invalid package name - wrong order',
+			filename: 'package.json',
+			code: '{ "name": "nodes-n8n-example", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'nodes-n8n-example' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: 'n8n-nodes-example' },
+							output: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'empty package name',
+			filename: 'package.json',
+			code: '{ "name": "", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: '' },
+					suggestions: [],
+				},
+			],
+		},
+		{
+			name: 'incomplete package name with missing suffix',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'n8n-nodes-' },
+					suggestions: [],
+				},
+			],
+		},
+		{
+			name: 'incomplete scoped package name with missing suffix',
+			filename: 'package.json',
+			code: '{ "name": "@company/n8n-nodes-", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: '@company/n8n-nodes-' },
+					suggestions: [],
+				},
+			],
+		},
+	],
+});