@n8n/eslint-plugin-community-nodes 0.31.0 → 0.33.0

package/src/rules/no-credential-reuse.ts

@@ -1,9 +1,8 @@
-import { TSESTree } from '@typescript-eslint/utils';
 import type { ReportSuggestionArray } from '@typescript-eslint/utils/ts-eslint';
 
 import {
 	isNodeTypeClass,
-	findClassProperty,
+	findNodeDescriptionObject,
 	findArrayLiteralProperty,
 	extractCredentialNameFromArray,
 	findPackageJson,
@@ -59,15 +58,12 @@ export const NoCredentialReuseRule = createRule({
 					return;
 				}
 
-				const descriptionProperty = findClassProperty(node, 'description');
-				if (
-					!descriptionProperty?.value ||
-					descriptionProperty.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression
-				) {
+				const description = findNodeDescriptionObject(node);
+				if (!description) {
 					return;
 				}
 
-				const credentialsArray = findArrayLiteralProperty(descriptionProperty.value, 'credentials');
+				const credentialsArray = findArrayLiteralProperty(description, 'credentials');
 				if (!credentialsArray) {
 					return;
 				}

package/src/rules/no-emoji-in-options.test.ts

@@ -16,6 +16,27 @@ function createNodeCode(body: string): string {
 	`;
 }
 
+/**
+ * Versioned node layout from the node-building docs: the version class assigns
+ * `description` in its constructor instead of as a property initializer.
+ */
+function createVersionedNodeCode(body: string): string {
+	return `
+		import type { INodeType, INodeTypeBaseDescription, INodeTypeDescription } from 'n8n-workflow';
+
+		export class TestNodeV1 implements INodeType {
+			description: INodeTypeDescription;
+
+			constructor(baseDescription: INodeTypeBaseDescription) {
+				this.description = {
+					...baseDescription,
+					${body}
+				};
+			}
+		}
+	`;
+}
+
 ruleTester.run('no-emoji-in-options', NoEmojiInOptionsRule, {
 	valid: [
 		{
@@ -75,6 +96,62 @@ ruleTester.run('no-emoji-in-options', NoEmojiInOptionsRule, {
 		},
 	],
 	invalid: [
+		{
+			name: 'emoji in option name of a versioned node assigning description in its constructor',
+			filename: '/tmp/v1/TestNodeV1.node.ts',
+			code: createVersionedNodeCode(`
+				version: 1,
+				properties: [
+					{
+						displayName: 'Operation',
+						name: 'operation',
+						type: 'options',
+						options: [
+							{ name: '✅ Create', value: 'create' },
+							{ name: 'Delete', value: 'delete' },
+						],
+						default: 'create',
+					},
+				],
+			`),
+			errors: [{ messageId: 'emojiInOption', data: { key: 'name', emoji: '✅' } }],
+		},
+		{
+			name: 'emoji in a description that is cast with `as`',
+			filename: '/tmp/TestNode.node.ts',
+			code: `
+				import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNode implements INodeType {
+					description = {
+						displayName: '🚀 Rocket Node',
+						name: 'testNode',
+						properties: [],
+					} as INodeTypeDescription;
+				}
+			`,
+			errors: [{ messageId: 'emojiInOption', data: { key: 'displayName', emoji: '🚀' } }],
+		},
+		{
+			name: 'emoji in a constructor-assigned description that is cast with `as`',
+			filename: '/tmp/v1/TestNodeV1.node.ts',
+			code: `
+				import type { INodeType, INodeTypeBaseDescription, INodeTypeDescription } from 'n8n-workflow';
+
+				export class TestNodeV1 implements INodeType {
+					description: INodeTypeDescription;
+
+					constructor(baseDescription: INodeTypeBaseDescription) {
+						this.description = {
+							...baseDescription,
+							displayName: '🚀 Rocket Node',
+							properties: [],
+						} as INodeTypeDescription;
+					}
+				}
+			`,
+			errors: [{ messageId: 'emojiInOption', data: { key: 'displayName', emoji: '🚀' } }],
+		},
 		{
 			name: 'emoji in node displayName',
 			filename: '/tmp/TestNode.node.ts',

package/src/rules/no-emoji-in-options.ts

@@ -3,7 +3,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
 	isNodeTypeClass,
-	findClassProperty,
+	findNodeDescriptionObject,
 	getStringLiteralValue,
 	isFileType,
 	createRule,
@@ -93,12 +93,12 @@ export const NoEmojiInOptionsRule = createRule({
 					return;
 				}
 
-				const descriptionProperty = findClassProperty(node, 'description');
-				if (!descriptionProperty?.value) {
+				const description = findNodeDescriptionObject(node);
+				if (!description) {
 					return;
 				}
 
-				traverse(descriptionProperty.value);
+				traverse(description);
 			},
 		};
 	},

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

@@ -41,7 +41,7 @@ export const NoForbiddenLifecycleScriptsRule = createRule({
 				}
 
 				const scriptsProp = findJsonProperty(node, 'scripts');
-				if (!scriptsProp || scriptsProp.value.type !== AST_NODE_TYPES.ObjectExpression) {
+				if (scriptsProp?.value.type !== AST_NODE_TYPES.ObjectExpression) {
 					return;
 				}
 

package/src/rules/no-unsafe-connection-type-cast.test.ts

@@ -0,0 +1,306 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { NoUnsafeConnectionTypeCastRule } from './no-unsafe-connection-type-cast.js';
+
+const ruleTester = new RuleTester();
+
+function createNodeCode(inputs: string, outputs: string): string {
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { NodeConnectionTypes } 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: ${inputs},
+		outputs: ${outputs},
+		properties: [],
+	};
+}`;
+}
+
+/** Lets a test spell the connection key itself, e.g. `'inputs'` or `['inputs']`. */
+function createNodeCodeWithProperty(property: string): string {
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { NodeConnectionTypes } 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' },
+		${property},
+		outputs: [NodeConnectionTypes.Main],
+		properties: [],
+	};
+}`;
+}
+
+const MAIN = '[NodeConnectionTypes.Main]';
+
+ruleTester.run('no-unsafe-connection-type-cast', NoUnsafeConnectionTypeCastRule, {
+	valid: [
+		{
+			name: 'class that does not implement INodeType',
+			code: 'export class RegularClass {\n\tsomeProperty = "value";\n}',
+		},
+		{
+			name: 'node without casts',
+			code: createNodeCode(MAIN, MAIN),
+		},
+		{
+			name: 'node with empty inputs and outputs',
+			code: createNodeCode('[]', '[]'),
+		},
+		{
+			name: 'dynamic inputs as a template literal expression',
+			code: createNodeCode('`={{ (() => [NodeConnectionTypes.Main])() }}`', MAIN),
+		},
+		{
+			name: 'as const narrows rather than erases',
+			code: createNodeCode(`${MAIN} as const`, MAIN),
+		},
+		{
+			name: 'satisfies keeps the type checked',
+			code: createNodeCode(`${MAIN} satisfies NodeConnectionType[]`, MAIN),
+		},
+		{
+			name: 'a named type assertion is still checked structurally',
+			code: createNodeCode(`${MAIN} as NodeConnectionType[]`, MAIN),
+		},
+		{
+			name: 'casts elsewhere in the description are untouched',
+			code: createNodeCode(MAIN, MAIN).replace('version: 1,', 'version: 1 as never,'),
+		},
+	],
+	invalid: [
+		{
+			name: 'as never on inputs',
+			code: createNodeCode("['main'] as never", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main']", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'as never on outputs',
+			code: createNodeCode(MAIN, "['main'] as never"),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'outputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode(MAIN, "['main']"),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'as never on both inputs and outputs',
+			code: createNodeCode("['main'] as never", "['main'] as never"),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main']", "['main'] as never"),
+						},
+					],
+				},
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'outputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main'] as never", "['main']"),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'as any',
+			code: createNodeCode("['main'] as any", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'any', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main']", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'as unknown',
+			code: createNodeCode("['main'] as unknown", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'unknown', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main']", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'double cast through unknown removes the whole chain',
+			code: createNodeCode("['main'] as unknown as NodeConnectionType[]", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'unknown', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main']", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'angle-bracket assertion',
+			code: createNodeCode("<never>['main']", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main']", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'erasing cast hidden behind an outer satisfies',
+			code: createNodeCode("['main'] as never satisfies NodeConnectionType[]", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main'] satisfies NodeConnectionType[]", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'erasing cast wrapped around an inner satisfies',
+			code: createNodeCode("['main'] satisfies NodeConnectionType[] as never", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("['main'] satisfies NodeConnectionType[]", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'cast nested under satisfies, with a second cast outside it',
+			code: createNodeCode("['main'] as never satisfies NodeConnectionType[] as unknown", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'unknown', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							// Both casts go, the satisfies between them stays.
+							output: createNodeCode("['main'] satisfies NodeConnectionType[]", MAIN),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'quoted connection key',
+			code: createNodeCodeWithProperty("'inputs': ['main'] as never"),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCodeWithProperty("'inputs': ['main']"),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'computed connection key',
+			code: createNodeCodeWithProperty("['inputs']: ['main'] as never"),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCodeWithProperty("['inputs']: ['main']"),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'cast hiding a malformed declaration',
+			code: createNodeCode("'not-an-array' as never", MAIN),
+			errors: [
+				{
+					messageId: 'erasingCast',
+					data: { typeName: 'never', property: 'inputs' },
+					suggestions: [
+						{
+							messageId: 'removeCast',
+							output: createNodeCode("'not-an-array'", MAIN),
+						},
+					],
+				},
+			],
+		},
+	],
+});

package/src/rules/no-unsafe-connection-type-cast.ts

@@ -0,0 +1,125 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
+import {
+	isNodeTypeClass,
+	findClassProperty,
+	findObjectProperty,
+	findJsonProperty,
+	createRule,
+} from '../utils/index.js';
+
+const ERASING_KEYWORDS: Partial<Record<AST_NODE_TYPES, string>> = {
+	[AST_NODE_TYPES.TSNeverKeyword]: 'never',
+	[AST_NODE_TYPES.TSAnyKeyword]: 'any',
+	[AST_NODE_TYPES.TSUnknownKeyword]: 'unknown',
+};
+
+type Cast = TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+
+function isCast(node: TSESTree.Node): node is Cast {
+	return (
+		node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSTypeAssertion
+	);
+}
+
+type Wrapper = Cast | TSESTree.TSSatisfiesExpression;
+
+function isWrapper(node: TSESTree.Node): node is Wrapper {
+	return isCast(node) || node.type === AST_NODE_TYPES.TSSatisfiesExpression;
+}
+
+/**
+ * Walks a wrapper chain such as `x as unknown as string[]` or
+ * `x as never satisfies string[]`, outermost first. `satisfies` is traversed
+ * but never collected: it checks the value instead of erasing its type, so it
+ * can hide a cast without being one.
+ */
+function collectCasts(node: TSESTree.Node): Cast[] {
+	const casts: Cast[] = [];
+	let current = node;
+	while (isWrapper(current)) {
+		if (isCast(current)) casts.push(current);
+		current = current.expression;
+	}
+	return casts;
+}
+
+/**
+ * Removes the cast syntax itself and nothing else, so every other part of the
+ * chain survives: a `satisfies` at any depth, and the expression's own text.
+ */
+function removeCastSyntax(fixer: TSESLint.RuleFixer, cast: Cast): TSESLint.RuleFix {
+	return cast.type === AST_NODE_TYPES.TSTypeAssertion
+		? // `<never>expr`: drop the leading `<never>`
+			fixer.removeRange([cast.range[0], cast.expression.range[0]])
+		: // `expr as never`: drop the trailing ` as never`
+			fixer.removeRange([cast.expression.range[1], cast.range[1]]);
+}
+
+export const NoUnsafeConnectionTypeCastRule = createRule({
+	name: 'no-unsafe-connection-type-cast',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Disallow type-erasing casts (`as never`, `as any`, `as unknown`) on node description `inputs`/`outputs`',
+		},
+		messages: {
+			erasingCast:
+				'Remove the `as {{typeName}}` cast on "{{property}}". It disables type checking, so a malformed connection declaration passes both TypeScript and lint.',
+			removeCast: 'Remove the cast',
+		},
+		hasSuggestions: true,
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		function checkProperty(value: TSESTree.Node, property: 'inputs' | 'outputs') {
+			const casts = collectCasts(value);
+			const [outermost] = casts;
+			if (!outermost) return;
+
+			// A chain is unsafe if any link erases the type, e.g. the `unknown`
+			// in `as unknown as string[]` is what defeats the checker.
+			const erasing = casts.find((cast) => ERASING_KEYWORDS[cast.typeAnnotation.type]);
+			if (!erasing) return;
+
+			// Report the outermost cast rather than the whole property value, so a
+			// `satisfies` wrapped around it stays put when the suggestion is applied.
+			context.report({
+				node: outermost,
+				messageId: 'erasingCast',
+				data: {
+					typeName: ERASING_KEYWORDS[erasing.typeAnnotation.type],
+					property,
+				},
+				suggest: [
+					{
+						messageId: 'removeCast',
+						fix: (fixer) => casts.map((cast) => removeCastSyntax(fixer, cast)),
+					},
+				],
+			});
+		}
+
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) return;
+
+				const descriptionProperty = findClassProperty(node, 'description');
+				if (!descriptionProperty) return;
+
+				const descriptionValue = descriptionProperty.value;
+				if (descriptionValue?.type !== AST_NODE_TYPES.ObjectExpression) return;
+
+				for (const prop of ['inputs', 'outputs'] as const) {
+					const property =
+						findObjectProperty(descriptionValue, prop) ?? findJsonProperty(descriptionValue, prop);
+					if (!property) continue;
+					checkProperty(property.value, prop);
+				}
+			},
+		};
+	},
+});

package/src/rules/node-class-description-icon-missing.ts

@@ -41,10 +41,7 @@ export const NodeClassDescriptionIconMissingRule = createRule({
 				}
 
 				const descriptionProperty = findClassProperty(node, 'description');
-				if (
-					!descriptionProperty?.value ||
-					descriptionProperty.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression
-				) {
+				if (descriptionProperty?.value?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
 					return;
 				}
 

package/src/rules/require-node-description-fields.ts

@@ -41,10 +41,7 @@ export const RequireNodeDescriptionFieldsRule = createRule({
 				}
 
 				const descriptionProperty = findClassProperty(node, 'description');
-				if (
-					!descriptionProperty?.value ||
-					descriptionProperty.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression
-				) {
+				if (descriptionProperty?.value?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
 					return;
 				}
 

package/src/rules/resource-operation-pattern.ts

@@ -30,15 +30,12 @@ export const ResourceOperationPatternRule = createRule({
 		}
 
 		const analyzeNodeDescription = (descriptionValue: TSESTree.Expression | null): void => {
-			if (!descriptionValue || descriptionValue.type !== AST_NODE_TYPES.ObjectExpression) {
+			if (descriptionValue?.type !== AST_NODE_TYPES.ObjectExpression) {
 				return;
 			}
 
 			const propertiesProperty = findObjectProperty(descriptionValue, 'properties');
-			if (
-				!propertiesProperty?.value ||
-				propertiesProperty.value.type !== AST_NODE_TYPES.ArrayExpression
-			) {
+			if (propertiesProperty?.value?.type !== AST_NODE_TYPES.ArrayExpression) {
 				return;
 			}
 
@@ -48,7 +45,7 @@ export const ResourceOperationPatternRule = createRule({
 			let operationNode: TSESTree.Node | null = null;
 
 			for (const property of propertiesArray.elements) {
-				if (!property || property.type !== AST_NODE_TYPES.ObjectExpression) {
+				if (property?.type !== AST_NODE_TYPES.ObjectExpression) {
 					continue;
 				}
 

package/src/rules/valid-author.ts

@@ -22,7 +22,7 @@ function parsePersonString(value: string): { name: string; email: string } {
 }
 
 function isNonEmptyStringLiteral(node: TSESTree.Property | null): boolean {
-	if (!node || node.value.type !== AST_NODE_TYPES.Literal) {
+	if (node?.value.type !== AST_NODE_TYPES.Literal) {
 		return false;
 	}
 	const { value } = node.value;