no-node-access.ts

import { ASTUtils } from '@typescript-eslint/utils';

import { createTestingLibraryRule } from '../create-testing-library-rule';
import {
	getDeepestIdentifierNode,
	isLiteral,
	isMemberExpression,
} from '../node-utils';
import {
	ALL_QUERIES_COMBINATIONS,
	ALL_RETURNING_NODES,
	EVENT_HANDLER_METHODS,
	resolveToTestingLibraryFn,
} from '../utils';

import type { TSESTree } from '@typescript-eslint/utils';

const RULE_NAME = 'no-node-access';
export type MessageIds = 'noNodeAccess';
export type Options = [{ allowContainerFirstChild: boolean }];

export default createTestingLibraryRule<Options, MessageIds>({
	name: RULE_NAME,
	meta: {
		type: 'problem',
		docs: {
			description: 'Disallow direct Node access',
			recommendedConfig: {
				dom: 'error',
				angular: 'error',
				react: 'error',
				vue: 'error',
				svelte: 'error',
				marko: 'error',
			},
		},
		messages: {
			noNodeAccess:
				'Avoid direct Node access. Prefer using the methods from Testing Library.',
		},
		schema: [
			{
				type: 'object',
				properties: {
					allowContainerFirstChild: {
						type: 'boolean',
					},
				},
				additionalProperties: false,
			},
		],
	},
	defaultOptions: [
		{
			allowContainerFirstChild: false,
		},
	],

	create(context, [{ allowContainerFirstChild = false }], helpers) {
		function showErrorForNodeAccess(node: TSESTree.MemberExpression) {
			// This rule is so aggressive that can cause tons of false positives outside test files when Aggressive Reporting
			// is enabled. Because of that, this rule will skip this mechanism and report only if some Testing Library package
			// or custom one (set in utils-module Shared Setting) is found.
			if (!helpers.isTestingLibraryImported(true)) {
				return;
			}

			// Skip if this MemberExpression is the object of another MemberExpression
			// to avoid duplicate reports for chained property access
			if (isMemberExpression(node.parent) && node.parent.object === node) {
				return;
			}

			const propertyName = ASTUtils.isIdentifier(node.property)
				? node.property.name
				: null;

			if (
				propertyName &&
				ALL_RETURNING_NODES.some(
					(allReturningNode) => allReturningNode === propertyName
				)
			) {
				if (allowContainerFirstChild && propertyName === 'firstChild') {
					return;
				}

				if (
					ASTUtils.isIdentifier(node.object) &&
					node.object.name === 'props'
				) {
					return;
				}

				context.report({
					node,
					loc: node.property.loc.start,
					messageId: 'noNodeAccess',
				});
			}
		}

		function getProperty(
			node: TSESTree.PrivateIdentifier | TSESTree.Expression
		) {
			if (isLiteral(node)) {
				return node;
			}

			return getDeepestIdentifierNode(node);
		}

		return {
			CallExpression(node: TSESTree.CallExpression) {
				if (!isMemberExpression(node.callee)) return;

				const { callee } = node;
				if (
					!EVENT_HANDLER_METHODS.some(
						(method) => method === ASTUtils.getPropertyName(callee)
					)
				) {
					return;
				}
				const identifier = getDeepestIdentifierNode(callee.object);

				if (
					!identifier ||
					!ALL_QUERIES_COMBINATIONS.includes(identifier.name)
				) {
					return;
				}

				if (resolveToTestingLibraryFn(node, context)) {
					const property = getProperty(callee.property);
					context.report({
						node,
						loc: property?.loc.start,
						messageId: 'noNodeAccess',
					});
				}
			},
			'ExpressionStatement MemberExpression': showErrorForNodeAccess,
			'VariableDeclarator MemberExpression': showErrorForNodeAccess,
		};
	},
});