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

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/valid-credential-references.test.ts

@@ -19,6 +19,7 @@ const mockFindPackageJson = vi.mocked(fileUtils.findPackageJson);
 const ruleTester = new RuleTester();
 
 const nodeFilePath = '/tmp/TestNode.node.ts';
+const versionedNodeFilePath = '/tmp/v1/TestNodeV1.node.ts';
 
 function createNodeCode(
 	credentials: Array<string | { name: string; required?: boolean }> = [],
@@ -97,6 +98,36 @@ export class TestNode implements INodeType {
 }`;
 }
 
+/**
+ * Versioned node layout from the node-building docs: each version class
+ * implements `INodeType` and assigns `description` in its constructor, merging
+ * the `baseDescription` that the `VersionedNodeType` entry file passes in.
+ */
+function createVersionedNodeCode(credentialNameLiteral: string): string {
+	return `
+import type { INodeType, INodeTypeBaseDescription, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNodeV1 implements INodeType {
+	description: INodeTypeDescription;
+
+	constructor(baseDescription: INodeTypeBaseDescription) {
+		this.description = {
+			...baseDescription,
+			version: 1,
+			inputs: ['main'],
+			outputs: ['main'],
+			credentials: [
+				{
+					name: ${credentialNameLiteral},
+					required: true,
+				},
+			],
+			properties: [],
+		};
+	}
+}`;
+}
+
 function createNonNodeClass(): string {
 	return `
 export class RegularClass {
@@ -153,8 +184,52 @@ ruleTester.run('valid-credential-references', ValidCredentialReferencesRule, {
 			filename: nodeFilePath,
 			code: createNonINodeTypeClass(),
 		},
+		{
+			name: 'versioned node assigning description in its constructor references a credential that exists',
+			filename: versionedNodeFilePath,
+			code: createVersionedNodeCode("'myApiCredential'"),
+		},
 	],
 	invalid: [
+		{
+			name: 'versioned node assigning description in its constructor references a credential that does not exist',
+			filename: versionedNodeFilePath,
+			code: createVersionedNodeCode("'myApiCredentail'"),
+			errors: [
+				{
+					messageId: 'credentialNotFound',
+					data: { credentialName: 'myApiCredentail' },
+					suggestions: [
+						{
+							messageId: 'didYouMean',
+							data: { suggestedName: 'myApiCredential' },
+							output: createVersionedNodeCode('"myApiCredential"'),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'credential name in a description cast with `as` does not exist in package',
+			filename: nodeFilePath,
+			code: `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		credentials: [{ name: 'brokenReference', required: true }],
+		properties: [],
+	} as INodeTypeDescription;
+}`,
+			errors: [
+				{
+					messageId: 'credentialNotFound',
+					data: { credentialName: 'brokenReference' },
+				},
+			],
+		},
 		{
 			name: 'credential name does not exist in package (object form)',
 			filename: nodeFilePath,

package/src/rules/valid-credential-references.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,
@@ -58,15 +57,12 @@ export const ValidCredentialReferencesRule = 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/utils/ast-utils.ts

@@ -68,6 +68,73 @@ export function findClassProperty(
 	return property?.type === AST_NODE_TYPES.PropertyDefinition ? property : null;
 }
 
+/**
+ * Returns the object literal behind an expression, and looks through the type
+ * assertions node authors write, e.g. `{ … } as INodeTypeDescription`.
+ */
+function asObjectExpression(node: TSESTree.Node | null): TSESTree.ObjectExpression | null {
+	let current = node;
+	while (
+		current?.type === AST_NODE_TYPES.TSAsExpression ||
+		current?.type === AST_NODE_TYPES.TSSatisfiesExpression ||
+		current?.type === AST_NODE_TYPES.TSTypeAssertion ||
+		current?.type === AST_NODE_TYPES.TSNonNullExpression
+	) {
+		current = current.expression;
+	}
+
+	return current?.type === AST_NODE_TYPES.ObjectExpression ? current : null;
+}
+
+function findConstructorAssignedDescription(
+	node: TSESTree.ClassDeclaration,
+): TSESTree.ObjectExpression | null {
+	const constructor = node.body.body.find(
+		(member) => member.type === AST_NODE_TYPES.MethodDefinition && member.kind === 'constructor',
+	);
+	if (constructor?.type !== AST_NODE_TYPES.MethodDefinition) {
+		return null;
+	}
+
+	for (const statement of constructor.value.body?.body ?? []) {
+		if (statement.type !== AST_NODE_TYPES.ExpressionStatement) continue;
+
+		const { expression } = statement;
+		if (
+			expression.type === AST_NODE_TYPES.AssignmentExpression &&
+			expression.operator === '=' &&
+			expression.left.type === AST_NODE_TYPES.MemberExpression &&
+			expression.left.object.type === AST_NODE_TYPES.ThisExpression &&
+			expression.left.property.type === AST_NODE_TYPES.Identifier &&
+			expression.left.property.name === 'description'
+		) {
+			const description = asObjectExpression(expression.right);
+			if (description) {
+				return description;
+			}
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Returns the `description` object literal of a node class. Versioned nodes
+ * follow the layout in the node-building docs and assign `this.description` in
+ * their constructor, so look there when the class property has no initializer.
+ */
+export function findNodeDescriptionObject(
+	node: TSESTree.ClassDeclaration,
+): TSESTree.ObjectExpression | null {
+	const property = findClassProperty(node, 'description');
+	const propertyValue = asObjectExpression(property?.value ?? null);
+	if (propertyValue) {
+		return propertyValue;
+	}
+
+	return findConstructorAssignedDescription(node);
+}
+
 export function findObjectProperty(
 	obj: TSESTree.ObjectExpression,
 	propertyName: string,