@n8n/eslint-plugin-community-nodes 0.13.0 → 0.15.0

package/src/rules/require-node-api-error.ts

@@ -0,0 +1,90 @@
+import { DefinitionType } from '@typescript-eslint/scope-manager';
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+
+import { isFileType } from '../utils/index.js';
+import { createRule } from '../utils/rule-creator.js';
+
+const ALLOWED_ERROR_CLASSES = new Set(['NodeApiError', 'NodeOperationError']);
+
+function getThrowCalleeName(argument: TSESTree.Expression): string | null {
+	if (argument.type === AST_NODE_TYPES.NewExpression) {
+		if (argument.callee.type === AST_NODE_TYPES.Identifier) {
+			return argument.callee.name;
+		}
+	}
+	return null;
+}
+
+function isInsideCatchClause(node: TSESTree.Node): boolean {
+	let current: TSESTree.Node | undefined = node.parent;
+	while (current) {
+		if (current.type === AST_NODE_TYPES.CatchClause) {
+			return true;
+		}
+		current = current.parent;
+	}
+	return false;
+}
+
+export const RequireNodeApiErrorRule = createRule({
+	name: 'require-node-api-error',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Require NodeApiError or NodeOperationError for error wrapping in catch blocks. ' +
+				'Raw errors lose HTTP context in the n8n UI.',
+		},
+		messages: {
+			useNodeApiError:
+				'Use `NodeApiError` or `NodeOperationError` instead of re-throwing raw errors. ' +
+				'Example: `throw new NodeApiError(this.getNode(), error as JsonObject)`',
+			useNodeApiErrorInsteadOfGeneric:
+				'Use `NodeApiError` or `NodeOperationError` instead of `{{ errorClass }}`. ' +
+				'Example: `throw new NodeApiError(this.getNode(), error as JsonObject)`',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		const isNodeFile = isFileType(context.filename, '.node.ts');
+		const isHelperFile =
+			context.filename.endsWith('.ts') &&
+			!isNodeFile &&
+			!isFileType(context.filename, '.credentials.ts');
+
+		if (!isNodeFile && !isHelperFile) {
+			return {};
+		}
+
+		return {
+			ThrowStatement(node) {
+				if (!isInsideCatchClause(node)) return;
+				if (!node.argument) return;
+
+				const { argument } = node;
+
+				if (argument.type === AST_NODE_TYPES.Identifier) {
+					const scope = context.sourceCode.getScope(node);
+					const ref = scope.references.find((r) => r.identifier === argument);
+					const isCatchParam =
+						ref?.resolved?.defs.some((def) => def.type === DefinitionType.CatchClause) ?? false;
+
+					if (isCatchParam) {
+						context.report({ node, messageId: 'useNodeApiError' });
+					}
+					return;
+				}
+
+				const calleeName = getThrowCalleeName(argument);
+				if (calleeName !== null && !ALLOWED_ERROR_CLASSES.has(calleeName)) {
+					context.report({
+						node,
+						messageId: 'useNodeApiErrorInsteadOfGeneric',
+						data: { errorClass: calleeName },
+					});
+				}
+			},
+		};
+	},
+});

package/src/rules/valid-credential-references.test.ts

@@ -0,0 +1,230 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { afterEach, beforeEach, describe, vi } from 'vitest';
+
+import { ValidCredentialReferencesRule } from './valid-credential-references.js';
+import * as fileUtils from '../utils/file-utils.js';
+
+vi.mock('../utils/file-utils.js', async () => {
+	const actual = await vi.importActual('../utils/file-utils.js');
+	return {
+		...actual,
+		readPackageJsonCredentials: vi.fn(),
+		findPackageJson: vi.fn(),
+	};
+});
+
+const mockReadPackageJsonCredentials = vi.mocked(fileUtils.readPackageJsonCredentials);
+const mockFindPackageJson = vi.mocked(fileUtils.findPackageJson);
+
+const ruleTester = new RuleTester();
+
+const nodeFilePath = '/tmp/TestNode.node.ts';
+
+function createNodeCode(
+	credentials: Array<string | { name: string; required?: boolean }> = [],
+): string {
+	const credentialsArray =
+		credentials.length > 0
+			? credentials
+					.map((cred) => {
+						if (typeof cred === 'string') {
+							return `'${cred}'`;
+						} else {
+							const required =
+								cred.required !== undefined ? `,\n\t\t\t\trequired: ${cred.required}` : '';
+							return `{\n\t\t\t\tname: '${cred.name}'${required},\n\t\t\t}`;
+						}
+					})
+					.join(',\n\t\t\t')
+			: '';
+
+	const credentialsProperty =
+		credentials.length > 0 ? `credentials: [\n\t\t\t${credentialsArray}\n\t\t],` : '';
+
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		${credentialsProperty}
+		properties: [],
+	};
+}`;
+}
+
+/** Same as createNodeCode but uses double quotes for the credential name — matches fixer output */
+function createExpectedNodeCode(
+	credentials: Array<string | { name: string; required?: boolean }> = [],
+): string {
+	const credentialsArray =
+		credentials.length > 0
+			? credentials
+					.map((cred) => {
+						if (typeof cred === 'string') {
+							return `"${cred}"`;
+						} else {
+							const required =
+								cred.required !== undefined ? `,\n\t\t\t\trequired: ${cred.required}` : '';
+							return `{\n\t\t\t\tname: "${cred.name}"${required},\n\t\t\t}`;
+						}
+					})
+					.join(',\n\t\t\t')
+			: '';
+
+	const credentialsProperty =
+		credentials.length > 0 ? `credentials: [\n\t\t\t${credentialsArray}\n\t\t],` : '';
+
+	return `
+import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
+
+export class TestNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['output'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		${credentialsProperty}
+		properties: [],
+	};
+}`;
+}
+
+function createNonNodeClass(): string {
+	return `
+export class RegularClass {
+	credentials = [
+		{ name: 'ExternalApi', required: true }
+	];
+}`;
+}
+
+function createNonINodeTypeClass(): string {
+	return `
+export class NotANode {
+	description = {
+		displayName: 'Not A Node',
+		credentials: [
+			{ name: 'ExternalApi', required: true }
+		]
+	};
+}`;
+}
+
+mockFindPackageJson.mockReturnValue('/tmp/package.json');
+mockReadPackageJsonCredentials.mockReturnValue(new Set(['myApiCredential', 'oauthApi']));
+
+ruleTester.run('valid-credential-references', ValidCredentialReferencesRule, {
+	valid: [
+		{
+			name: 'node referencing a credential that exists (object form)',
+			filename: nodeFilePath,
+			code: createNodeCode([{ name: 'myApiCredential', required: true }]),
+		},
+		{
+			name: 'node referencing a credential that exists (string form)',
+			filename: nodeFilePath,
+			code: createNodeCode(['myApiCredential']),
+		},
+		{
+			name: 'node referencing multiple credentials that all exist',
+			filename: nodeFilePath,
+			code: createNodeCode(['myApiCredential', { name: 'oauthApi', required: false }]),
+		},
+		{
+			name: 'node without credentials array',
+			filename: nodeFilePath,
+			code: createNodeCode(),
+		},
+		{
+			name: 'non-node file ignored',
+			filename: '/tmp/regular-file.ts',
+			code: createNonNodeClass(),
+		},
+		{
+			name: 'non-INodeType class ignored',
+			filename: nodeFilePath,
+			code: createNonINodeTypeClass(),
+		},
+	],
+	invalid: [
+		{
+			name: 'credential name does not exist in package (object form)',
+			filename: nodeFilePath,
+			code: createNodeCode([{ name: 'brokenReference', required: true }]),
+			errors: [
+				{
+					messageId: 'credentialNotFound',
+					data: { credentialName: 'brokenReference' },
+				},
+			],
+		},
+		{
+			name: 'credential name does not exist in package (string form)',
+			filename: nodeFilePath,
+			code: createNodeCode(['unknownCredential']),
+			errors: [
+				{
+					messageId: 'credentialNotFound',
+					data: { credentialName: 'unknownCredential' },
+				},
+			],
+		},
+		{
+			name: 'credential name is a typo close to an existing credential — suggestion provided',
+			filename: nodeFilePath,
+			code: createNodeCode([{ name: 'myApiCredentail', required: true }]),
+			errors: [
+				{
+					messageId: 'credentialNotFound',
+					data: { credentialName: 'myApiCredentail' },
+					suggestions: [
+						{
+							messageId: 'didYouMean',
+							data: { suggestedName: 'myApiCredential' },
+							output: createExpectedNodeCode([{ name: 'myApiCredential', required: true }]),
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'mix of valid and invalid credentials — only invalid reported',
+			filename: nodeFilePath,
+			code: createNodeCode(['myApiCredential', { name: 'brokenRef', required: true }]),
+			errors: [
+				{
+					messageId: 'credentialNotFound',
+					data: { credentialName: 'brokenRef' },
+				},
+			],
+		},
+	],
+});
+
+describe('valid-credential-references — no package.json found', () => {
+	beforeEach(() => {
+		mockFindPackageJson.mockReturnValue(null);
+	});
+	afterEach(() => {
+		mockFindPackageJson.mockReturnValue('/tmp/package.json');
+	});
+
+	ruleTester.run('valid-credential-references (no package.json)', ValidCredentialReferencesRule, {
+		valid: [
+			{
+				name: 'check is skipped when package.json cannot be found',
+				filename: nodeFilePath,
+				code: createNodeCode([{ name: 'anyCredential', required: true }]),
+			},
+		],
+		invalid: [],
+	});
+});

package/src/rules/valid-credential-references.ts

@@ -0,0 +1,105 @@
+import { TSESTree } from '@typescript-eslint/types';
+import type { ReportSuggestionArray } from '@typescript-eslint/utils/ts-eslint';
+
+import {
+	isNodeTypeClass,
+	findClassProperty,
+	findArrayLiteralProperty,
+	extractCredentialNameFromArray,
+	findPackageJson,
+	readPackageJsonCredentials,
+	isFileType,
+	findSimilarStrings,
+	createRule,
+} from '../utils/index.js';
+
+export const ValidCredentialReferencesRule = createRule({
+	name: 'valid-credential-references',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Ensure credentials referenced in node descriptions exist as credential classes in the package',
+		},
+		messages: {
+			credentialNotFound:
+				'Credential "{{ credentialName }}" does not exist in this package. Check for typos or ensure the credential class is declared and listed in package.json.',
+			didYouMean: "Did you mean '{{ suggestedName }}'?",
+		},
+		schema: [],
+		hasSuggestions: true,
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!isFileType(context.filename, '.node.ts')) {
+			return {};
+		}
+
+		let packageCredentials: Set<string> | null = null;
+
+		const loadPackageCredentials = (): Set<string> => {
+			if (packageCredentials !== null) {
+				return packageCredentials;
+			}
+
+			const packageJsonPath = findPackageJson(context.filename);
+			if (!packageJsonPath) {
+				packageCredentials = new Set();
+				return packageCredentials;
+			}
+
+			packageCredentials = readPackageJsonCredentials(packageJsonPath);
+			return packageCredentials;
+		};
+
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) {
+					return;
+				}
+
+				const descriptionProperty = findClassProperty(node, 'description');
+				if (
+					!descriptionProperty?.value ||
+					descriptionProperty.value.type !== TSESTree.AST_NODE_TYPES.ObjectExpression
+				) {
+					return;
+				}
+
+				const credentialsArray = findArrayLiteralProperty(descriptionProperty.value, 'credentials');
+				if (!credentialsArray) {
+					return;
+				}
+
+				const knownCredentials = loadPackageCredentials();
+				if (knownCredentials.size === 0) {
+					return;
+				}
+
+				credentialsArray.elements.forEach((element) => {
+					const credentialInfo = extractCredentialNameFromArray(element);
+					if (!credentialInfo || knownCredentials.has(credentialInfo.name)) {
+						return;
+					}
+
+					const similar = findSimilarStrings(credentialInfo.name, knownCredentials);
+					const suggestions: ReportSuggestionArray<'credentialNotFound' | 'didYouMean'> =
+						similar.map((suggestedName) => ({
+							messageId: 'didYouMean' as const,
+							data: { suggestedName },
+							fix(fixer) {
+								return fixer.replaceText(credentialInfo.node, `"${suggestedName}"`);
+							},
+						}));
+
+					context.report({
+						node: credentialInfo.node,
+						messageId: 'credentialNotFound',
+						data: { credentialName: credentialInfo.name },
+						suggest: suggestions,
+					});
+				});
+			},
+		};
+	},
+});

package/src/rules/valid-peer-dependencies.test.ts

@@ -0,0 +1,130 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { ValidPeerDependenciesRule } from './valid-peer-dependencies.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('valid-peer-dependencies', ValidPeerDependenciesRule, {
+	valid: [
+		{
+			name: 'only n8n-workflow with "*"',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*" } }',
+		},
+		{
+			name: 'n8n-workflow and ai-node-sdk',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*", "ai-node-sdk": "*" } }',
+		},
+		{
+			name: 'n8n-workflow and ai-node-sdk with a version range (ai-node-sdk shape is checked by ai-node-package-json rule)',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*", "ai-node-sdk": "^1.0.0" } }',
+		},
+		{
+			name: 'non-package.json file is ignored',
+			filename: 'some-config.json',
+			code: '{ "peerDependencies": { "n8n-core": "*" } }',
+		},
+		{
+			name: 'nested objects are not checked',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*" }, "config": { "peerDependencies": { "n8n-core": "*" } } }',
+		},
+	],
+	invalid: [
+		{
+			name: 'missing peerDependencies section entirely',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+			output:
+				'{ "name": "n8n-nodes-example", "version": "1.0.0", "peerDependencies": { "n8n-workflow": "*" } }',
+			errors: [{ messageId: 'missingPeerDependencies' }],
+		},
+		{
+			name: 'empty peerDependencies section',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": {} }',
+			output: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*" } }',
+			errors: [{ messageId: 'missingN8nWorkflow' }],
+		},
+		{
+			name: 'peerDependencies missing n8n-workflow but has ai-node-sdk',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "ai-node-sdk": "*" } }',
+			output:
+				'{ "name": "n8n-nodes-example", "peerDependencies": { "ai-node-sdk": "*", "n8n-workflow": "*" } }',
+			errors: [{ messageId: 'missingN8nWorkflow' }],
+		},
+		{
+			name: 'n8n-workflow pinned to a specific version',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "^1.0.0" } }',
+			output: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*" } }',
+			errors: [{ messageId: 'pinnedN8nWorkflow', data: { value: '"^1.0.0"' } }],
+		},
+		{
+			name: 'forbidden n8n-core peer dependency (CNOC-404 Sinch)',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*", "n8n-core": "*" } }',
+			errors: [{ messageId: 'forbiddenPeerDependency', data: { name: 'n8n-core' } }],
+		},
+		{
+			name: 'forbidden arbitrary peer dependency',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*", "lodash": "^4.0.0" } }',
+			errors: [{ messageId: 'forbiddenPeerDependency', data: { name: 'lodash' } }],
+		},
+		{
+			name: 'multiple forbidden peer dependencies reported separately',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*", "n8n-core": "*", "axios": "^1.0.0" } }',
+			errors: [
+				{ messageId: 'forbiddenPeerDependency', data: { name: 'n8n-core' } },
+				{ messageId: 'forbiddenPeerDependency', data: { name: 'axios' } },
+			],
+		},
+		{
+			name: 'completely empty package.json gets peerDependencies inserted',
+			filename: 'package.json',
+			code: '{}',
+			output: '{ "peerDependencies": { "n8n-workflow": "*" } }',
+			errors: [{ messageId: 'missingPeerDependencies' }],
+		},
+		{
+			name: 'n8n-workflow value is a non-literal (object) — not auto-fixable',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": { "version": "*" } } }',
+			errors: [{ messageId: 'pinnedN8nWorkflow', data: { value: 'non-literal' } }],
+		},
+		{
+			name: 'peerDependencies is a string instead of an object',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": "n8n-workflow" }',
+			errors: [{ messageId: 'invalidPeerDependenciesType' }],
+		},
+		{
+			name: 'peerDependencies is an array instead of an object',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": ["n8n-workflow"] }',
+			errors: [{ messageId: 'invalidPeerDependenciesType' }],
+		},
+		{
+			name: 'peerDependencies is null',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": null }',
+			errors: [{ messageId: 'invalidPeerDependenciesType' }],
+		},
+		{
+			name: 'pinned n8n-workflow combined with forbidden entry',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "1.0.0", "n8n-core": "*" } }',
+			output:
+				'{ "name": "n8n-nodes-example", "peerDependencies": { "n8n-workflow": "*", "n8n-core": "*" } }',
+			errors: [
+				{ messageId: 'pinnedN8nWorkflow', data: { value: '"1.0.0"' } },
+				{ messageId: 'forbiddenPeerDependency', data: { name: 'n8n-core' } },
+			],
+		},
+	],
+});

package/src/rules/valid-peer-dependencies.ts

@@ -0,0 +1,116 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import { createRule, findJsonProperty } from '../utils/index.js';
+
+const REQUIRED_DEP = 'n8n-workflow';
+const REQUIRED_VERSION = '*';
+const ALLOWED_DEPS = new Set([REQUIRED_DEP, 'ai-node-sdk']);
+
+export const ValidPeerDependenciesRule = createRule({
+	name: 'valid-peer-dependencies',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Require community node package.json peerDependencies to contain only "n8n-workflow": "*" (and optionally "ai-node-sdk")',
+		},
+		fixable: 'code',
+		messages: {
+			missingPeerDependencies: `The package.json must have a "peerDependencies" section containing "${REQUIRED_DEP}": "${REQUIRED_VERSION}".`,
+			invalidPeerDependenciesType: `"peerDependencies" must be an object mapping package names to version ranges (containing "${REQUIRED_DEP}": "${REQUIRED_VERSION}").`,
+			missingN8nWorkflow: `"peerDependencies" must include "${REQUIRED_DEP}": "${REQUIRED_VERSION}".`,
+			pinnedN8nWorkflow: `"peerDependencies.${REQUIRED_DEP}" must be "${REQUIRED_VERSION}", got {{ value }}.`,
+			forbiddenPeerDependency:
+				'"{{ name }}" is not allowed in "peerDependencies". Only "n8n-workflow" and "ai-node-sdk" are permitted.',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!context.filename.endsWith('package.json')) {
+			return {};
+		}
+
+		return {
+			ObjectExpression(node: TSESTree.ObjectExpression) {
+				if (node.parent?.type !== AST_NODE_TYPES.ExpressionStatement) {
+					return;
+				}
+
+				const peerDepsProp = findJsonProperty(node, 'peerDependencies');
+
+				if (!peerDepsProp) {
+					context.report({
+						node,
+						messageId: 'missingPeerDependencies',
+						fix(fixer) {
+							const insertion = `"peerDependencies": { "${REQUIRED_DEP}": "${REQUIRED_VERSION}" }`;
+							const lastProp = node.properties[node.properties.length - 1];
+							if (!lastProp) {
+								return fixer.replaceText(node, `{ ${insertion} }`);
+							}
+							return fixer.insertTextAfter(lastProp, `, ${insertion}`);
+						},
+					});
+					return;
+				}
+
+				if (peerDepsProp.value.type !== AST_NODE_TYPES.ObjectExpression) {
+					context.report({
+						node: peerDepsProp,
+						messageId: 'invalidPeerDependenciesType',
+					});
+					return;
+				}
+
+				const peerDepsObject = peerDepsProp.value;
+				const workflowEntry = findJsonProperty(peerDepsObject, REQUIRED_DEP);
+
+				if (!workflowEntry) {
+					context.report({
+						node: peerDepsProp,
+						messageId: 'missingN8nWorkflow',
+						fix(fixer) {
+							const insertion = `"${REQUIRED_DEP}": "${REQUIRED_VERSION}"`;
+							const lastProp = peerDepsObject.properties[peerDepsObject.properties.length - 1];
+							if (!lastProp) {
+								return fixer.replaceText(peerDepsObject, `{ ${insertion} }`);
+							}
+							return fixer.insertTextAfter(lastProp, `, ${insertion}`);
+						},
+					});
+				} else if (
+					workflowEntry.value.type !== AST_NODE_TYPES.Literal ||
+					workflowEntry.value.value !== REQUIRED_VERSION
+				) {
+					const valueNode = workflowEntry.value;
+					const rawValue =
+						valueNode.type === AST_NODE_TYPES.Literal ? String(valueNode.raw) : 'non-literal';
+					context.report({
+						node: workflowEntry,
+						messageId: 'pinnedN8nWorkflow',
+						data: { value: rawValue },
+						fix(fixer) {
+							if (valueNode.type !== AST_NODE_TYPES.Literal) return null;
+							return fixer.replaceText(valueNode, `"${REQUIRED_VERSION}"`);
+						},
+					});
+				}
+
+				for (const prop of peerDepsObject.properties) {
+					if (prop.type !== AST_NODE_TYPES.Property) continue;
+					if (prop.key.type !== AST_NODE_TYPES.Literal) continue;
+					const name = prop.key.value;
+					if (typeof name !== 'string') continue;
+					if (ALLOWED_DEPS.has(name)) continue;
+					context.report({
+						node: prop,
+						messageId: 'forbiddenPeerDependency',
+						data: { name },
+					});
+				}
+			},
+		};
+	},
+});