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

package/README.md

@@ -88,6 +88,7 @@ export default [
 | [valid-author](docs/rules/valid-author.md)                                               | Require a non-empty author name and email in package.json                                                                                                                              | ✅ ☑️ |      |    |    |    |
 | [valid-credential-references](docs/rules/valid-credential-references.md)                 | Ensure credentials referenced in node descriptions exist as credential classes in the package                                                                                          | ✅ ☑️ |      |    | 💡 |    |
 | [valid-description](docs/rules/valid-description.md)                                     | Require a non-empty "description" field in community node package.json                                                                                                                 | ✅ ☑️ |      |    |    |    |
+| [valid-node-categories](docs/rules/valid-node-categories.md)                             | Require supported community node categories in .node.json codex files                                                                                                                  | ✅ ☑️ |      |    |    |    |
 | [valid-peer-dependencies](docs/rules/valid-peer-dependencies.md)                         | Require community node package.json peerDependencies to contain only "n8n-workflow": "*" (and optionally "@n8n/ai-node-sdk")                                                           | ✅ ☑️ |      | 🔧 |    |    |
 | [webhook-lifecycle-complete](docs/rules/webhook-lifecycle-complete.md)                   | Require webhook trigger nodes to implement the complete webhookMethods lifecycle (checkExists, create, delete)                                                                         | ✅ ☑️ |      |    |    |    |
 

package/dist/plugin.d.ts

@@ -55,6 +55,7 @@ declare const configs: {
             '@n8n/community-nodes/valid-author': "error";
             '@n8n/community-nodes/valid-credential-references': "error";
             '@n8n/community-nodes/valid-description': "error";
+            '@n8n/community-nodes/valid-node-categories': "error";
             '@n8n/community-nodes/valid-peer-dependencies': "error";
             '@n8n/community-nodes/webhook-lifecycle-complete': "error";
         };
@@ -111,6 +112,7 @@ declare const configs: {
             '@n8n/community-nodes/valid-author': "error";
             '@n8n/community-nodes/valid-credential-references': "error";
             '@n8n/community-nodes/valid-description': "error";
+            '@n8n/community-nodes/valid-node-categories': "error";
             '@n8n/community-nodes/valid-peer-dependencies': "error";
             '@n8n/community-nodes/webhook-lifecycle-complete': "error";
         };
@@ -178,6 +180,7 @@ declare const pluginWithConfigs: {
                 '@n8n/community-nodes/valid-author': "error";
                 '@n8n/community-nodes/valid-credential-references': "error";
                 '@n8n/community-nodes/valid-description': "error";
+                '@n8n/community-nodes/valid-node-categories': "error";
                 '@n8n/community-nodes/valid-peer-dependencies': "error";
                 '@n8n/community-nodes/webhook-lifecycle-complete': "error";
             };
@@ -234,6 +237,7 @@ declare const pluginWithConfigs: {
                 '@n8n/community-nodes/valid-author': "error";
                 '@n8n/community-nodes/valid-credential-references': "error";
                 '@n8n/community-nodes/valid-description': "error";
+                '@n8n/community-nodes/valid-node-categories': "error";
                 '@n8n/community-nodes/valid-peer-dependencies': "error";
                 '@n8n/community-nodes/webhook-lifecycle-complete': "error";
             };
@@ -302,6 +306,7 @@ declare const n8nCommunityNodesPlugin: {
                 '@n8n/community-nodes/valid-author': "error";
                 '@n8n/community-nodes/valid-credential-references': "error";
                 '@n8n/community-nodes/valid-description': "error";
+                '@n8n/community-nodes/valid-node-categories': "error";
                 '@n8n/community-nodes/valid-peer-dependencies': "error";
                 '@n8n/community-nodes/webhook-lifecycle-complete': "error";
             };
@@ -358,6 +363,7 @@ declare const n8nCommunityNodesPlugin: {
                 '@n8n/community-nodes/valid-author': "error";
                 '@n8n/community-nodes/valid-credential-references': "error";
                 '@n8n/community-nodes/valid-description': "error";
+                '@n8n/community-nodes/valid-node-categories': "error";
                 '@n8n/community-nodes/valid-peer-dependencies': "error";
                 '@n8n/community-nodes/webhook-lifecycle-complete': "error";
             };

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAG7C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAYzC,QAAA,MAAM,OAAO;;;;YAIV,sBAAsB;;oBAZvB,IAAI;oBACJ,OAAO;oBACP,SAAS;;uBAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA0DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CgB,CAAC;AAE1C,QAAA,MAAM,iBAAiB;;QA/GrB,IAAI;QACJ,OAAO;QACP,SAAS;;WAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;gBAOpC,sBAAsB;;wBAZvB,IAAI;wBACJ,OAAO;wBACP,SAAS;;2BAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA0DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgD+C,CAAC;AAEzE,QAAA,MAAM,uBAAuB;;QAjH3B,IAAI;QACJ,OAAO;QACP,SAAS;;WAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;gBAOpC,sBAAsB;;wBAZvB,IAAI;wBACJ,OAAO;wBACP,SAAS;;2BAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA0DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDwB,CAAC;eACnC,iBAAiB;AAChC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAG7C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAYzC,QAAA,MAAM,OAAO;;;;YAIV,sBAAsB;;oBAZvB,IAAI;oBACJ,OAAO;oBACP,SAAS;;uBAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CgB,CAAC;AAE1C,QAAA,MAAM,iBAAiB;;QAjHrB,IAAI;QACJ,OAAO;QACP,SAAS;;WAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;gBAOpC,sBAAsB;;wBAZvB,IAAI;wBACJ,OAAO;wBACP,SAAS;;2BAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD+C,CAAC;AAEzE,QAAA,MAAM,uBAAuB;;QAnH3B,IAAI;QACJ,OAAO;QACP,SAAS;;WAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;gBAOpC,sBAAsB;;wBAZvB,IAAI;wBACJ,OAAO;wBACP,SAAS;;2BAGM,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDwB,CAAC;eACnC,iBAAiB;AAChC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/plugin.js

@@ -57,6 +57,7 @@ const configs = {
             '@n8n/community-nodes/valid-author': 'error',
             '@n8n/community-nodes/valid-credential-references': 'error',
             '@n8n/community-nodes/valid-description': 'error',
+            '@n8n/community-nodes/valid-node-categories': 'error',
             '@n8n/community-nodes/valid-peer-dependencies': 'error',
             '@n8n/community-nodes/webhook-lifecycle-complete': 'error',
         },
@@ -106,6 +107,7 @@ const configs = {
             '@n8n/community-nodes/valid-author': 'error',
             '@n8n/community-nodes/valid-credential-references': 'error',
             '@n8n/community-nodes/valid-description': 'error',
+            '@n8n/community-nodes/valid-node-categories': 'error',
             '@n8n/community-nodes/valid-peer-dependencies': 'error',
             '@n8n/community-nodes/webhook-lifecycle-complete': 'error',
         },

package/dist/rules/index.d.ts

@@ -130,6 +130,9 @@ export declare const rules: {
     'valid-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"emptyDescription" | "missingDescription", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    'valid-node-categories': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidCategories" | "invalidCategory" | "invalidCategoryType" | "marketingCategory", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
     'valid-peer-dependencies': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenPeerDependency" | "invalidPeerDependenciesType" | "missingN8nWorkflow" | "missingPeerDependencies" | "pinnedN8nWorkflow", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };

package/dist/rules/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AA+CA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAgDA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CuB,CAAC"}

package/dist/rules/index.js

@@ -40,6 +40,7 @@ import { TriggerNodeConventionsRule } from './trigger-node-conventions.js';
 import { ValidAuthorRule } from './valid-author.js';
 import { ValidCredentialReferencesRule } from './valid-credential-references.js';
 import { ValidDescriptionRule } from './valid-description.js';
+import { ValidNodeCategoriesRule } from './valid-node-categories.js';
 import { ValidPeerDependenciesRule } from './valid-peer-dependencies.js';
 import { WebhookLifecycleCompleteRule } from './webhook-lifecycle-complete.js';
 export const rules = {
@@ -85,6 +86,7 @@ export const rules = {
     'valid-author': ValidAuthorRule,
     'valid-credential-references': ValidCredentialReferencesRule,
     'valid-description': ValidDescriptionRule,
+    'valid-node-categories': ValidNodeCategoriesRule,
     'valid-peer-dependencies': ValidPeerDependenciesRule,
     'webhook-lifecycle-complete': WebhookLifecycleCompleteRule,
 };

package/dist/rules/no-silent-error-swallowing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-silent-error-swallowing.d.ts","sourceRoot":"","sources":["../../src/rules/no-silent-error-swallowing.ts"],"names":[],"mappings":"AA6CA,eAAO,MAAM,2BAA2B;;CAiFtC,CAAC"}
+{"version":3,"file":"no-silent-error-swallowing.d.ts","sourceRoot":"","sources":["../../src/rules/no-silent-error-swallowing.ts"],"names":[],"mappings":"AAsCA,eAAO,MAAM,2BAA2B;;CAiFtC,CAAC"}

package/dist/rules/no-silent-error-swallowing.js

@@ -1,16 +1,6 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import { createRule, findClassProperty, isNodeTypeClass, WEBHOOK_LIFECYCLE_METHODS, } from '../utils/index.js';
+import { createRule, findClassProperty, getPropertyKeyName, isNodeTypeClass, WEBHOOK_LIFECYCLE_METHODS, } from '../utils/index.js';
 const LIFECYCLE_METHODS = WEBHOOK_LIFECYCLE_METHODS;
-/** Returns the static name of a non-computed object property key, or null. */
-function getPropertyName(property) {
-    if (property.computed)
-        return null;
-    if (property.key.type === AST_NODE_TYPES.Identifier)
-        return property.key.name;
-    if (property.key.type === AST_NODE_TYPES.Literal)
-        return String(property.key.value);
-    return null;
-}
 function isFunctionNode(node) {
     return (node.type === AST_NODE_TYPES.FunctionDeclaration ||
         node.type === AST_NODE_TYPES.FunctionExpression ||
@@ -70,7 +60,7 @@ export const NoSilentErrorSwallowingRule = createRule({
                     for (const methodProperty of groupProperty.value.properties) {
                         if (methodProperty.type !== AST_NODE_TYPES.Property)
                             continue;
-                        const methodName = getPropertyName(methodProperty);
+                        const methodName = getPropertyKeyName(methodProperty);
                         if (methodName === null || !LIFECYCLE_METHODS.includes(methodName))
                             continue;
                         const fn = methodProperty.value;

package/dist/rules/valid-node-categories.d.ts

@@ -0,0 +1,4 @@
+export declare const ValidNodeCategoriesRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidCategories" | "invalidCategory" | "invalidCategoryType" | "marketingCategory", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+//# sourceMappingURL=valid-node-categories.d.ts.map

package/dist/rules/valid-node-categories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valid-node-categories.d.ts","sourceRoot":"","sources":["../../src/rules/valid-node-categories.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,uBAAuB;;CAqDlC,CAAC"}

package/dist/rules/valid-node-categories.js

@@ -0,0 +1,68 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createRule, findJsonProperty, getTopLevelObjectInJson } from '../utils/index.js';
+const validCategories = new Set([
+    'Data & Storage',
+    'Finance & Accounting',
+    'Marketing & Content',
+    'Productivity',
+    'Miscellaneous',
+    'Sales',
+    'Development',
+    'Analytics',
+    'Communication',
+    'Utility',
+]);
+export const ValidNodeCategoriesRule = createRule({
+    name: 'valid-node-categories',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require supported community node categories in .node.json codex files',
+        },
+        messages: {
+            invalidCategories: '"categories" must be a non-empty array of community node categories.',
+            invalidCategoryType: 'Each category must be a string from the community node category list.',
+            invalidCategory: '"{{ category }}" is not a supported community node category. See https://docs.n8n.io/connect/create-nodes/build-your-node/reference/codex-files/#node-categories for the allowed values.',
+            marketingCategory: '"Marketing" is not a supported category. Use "Marketing & Content".',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        if (!context.filename.endsWith('.node.json'))
+            return {};
+        return {
+            ObjectExpression(node) {
+                const root = getTopLevelObjectInJson(node);
+                if (!root)
+                    return;
+                const categories = findJsonProperty(root, 'categories');
+                if (!categories)
+                    return;
+                if (categories.value.type !== AST_NODE_TYPES.ArrayExpression ||
+                    categories.value.elements.length === 0) {
+                    context.report({ node: categories.value, messageId: 'invalidCategories' });
+                    return;
+                }
+                for (const category of categories.value.elements) {
+                    if (!category)
+                        continue;
+                    if (category.type !== AST_NODE_TYPES.Literal || typeof category.value !== 'string') {
+                        context.report({ node: category, messageId: 'invalidCategoryType' });
+                    }
+                    else if (category.value === 'Marketing') {
+                        context.report({ node: category, messageId: 'marketingCategory' });
+                    }
+                    else if (!validCategories.has(category.value)) {
+                        context.report({
+                            node: category,
+                            messageId: 'invalidCategory',
+                            data: { category: category.value },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=valid-node-categories.js.map

package/dist/rules/webhook-lifecycle-complete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhook-lifecycle-complete.d.ts","sourceRoot":"","sources":["../../src/rules/webhook-lifecycle-complete.ts"],"names":[],"mappings":"AA8CA,eAAO,MAAM,4BAA4B;;CAkFvC,CAAC"}
+{"version":3,"file":"webhook-lifecycle-complete.d.ts","sourceRoot":"","sources":["../../src/rules/webhook-lifecycle-complete.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,4BAA4B;;CA6EvC,CAAC"}

package/dist/rules/webhook-lifecycle-complete.js

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import { createRule, findClassProperty, findObjectProperty, isNodeTypeClass, WEBHOOK_LIFECYCLE_METHODS, } from '../utils/index.js';
+import { createRule, findClassProperty, findObjectProperty, getPropertyKeyName, isNodeTypeClass, WEBHOOK_LIFECYCLE_METHODS, } from '../utils/index.js';
 /**
  * Returns true if the description declares webhook endpoints, indicating the
  * node is a webhook-based trigger that needs a complete lifecycle.
@@ -17,11 +17,7 @@ function hasWebhooksDeclared(descriptionValue) {
 function isMethodProperty(property, name) {
     if (property.type !== AST_NODE_TYPES.Property)
         return false;
-    if (property.computed)
-        return false;
-    const keyMatches = (property.key.type === AST_NODE_TYPES.Identifier && property.key.name === name) ||
-        (property.key.type === AST_NODE_TYPES.Literal && property.key.value === name);
-    if (!keyMatches)
+    if (getPropertyKeyName(property) !== name)
         return false;
     return (property.value.type === AST_NODE_TYPES.FunctionExpression ||
         property.value.type === AST_NODE_TYPES.ArrowFunctionExpression);
@@ -81,11 +77,7 @@ export const WebhookLifecycleCompleteRule = createRule({
                         continue;
                     if (groupProperty.value.type !== AST_NODE_TYPES.ObjectExpression)
                         continue;
-                    const groupName = groupProperty.key.type === AST_NODE_TYPES.Identifier
-                        ? groupProperty.key.name
-                        : groupProperty.key.type === AST_NODE_TYPES.Literal
-                            ? String(groupProperty.key.value)
-                            : 'default';
+                    const groupName = getPropertyKeyName(groupProperty) ?? 'default';
                     const missing = findMissingMethods(groupProperty.value);
                     if (missing.length === 0)
                         continue;

package/dist/utils/ast-utils.d.ts

@@ -9,6 +9,12 @@ export declare function isTriggerNodeClass(node: TSESTree.ClassDeclaration): boo
  * `group` values.
  */
 export declare function isTriggerNode(node: TSESTree.ClassDeclaration, descriptionValue: TSESTree.ObjectExpression): boolean;
+/**
+ * Returns the name a property key stands for, or null when it is only known at
+ * runtime. `delete`, `'delete'` and `['delete']` all name the same property, so
+ * how the key is written must not decide whether a rule sees it.
+ */
+export declare function getPropertyKeyName(property: TSESTree.Property | TSESTree.PropertyDefinition | TSESTree.MethodDefinition): string | null;
 export declare function findClassProperty(node: TSESTree.ClassDeclaration, propertyName: string): TSESTree.PropertyDefinition | null;
 /**
  * Returns the `description` object literal of a node class. Versioned nodes

package/dist/utils/ast-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../src/utils/ast-utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../src/utils/ast-utils.ts"],"names":[],"mappings":"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"}

package/dist/utils/ast-utils.js

@@ -33,10 +33,29 @@ function hasTriggerGroup(descriptionValue) {
 export function isTriggerNode(node, descriptionValue) {
     return hasTriggerGroup(descriptionValue) || isTriggerNodeClass(node);
 }
+/**
+ * Returns the name a property key stands for, or null when it is only known at
+ * runtime. `delete`, `'delete'` and `['delete']` all name the same property, so
+ * how the key is written must not decide whether a rule sees it.
+ */
+export function getPropertyKeyName(property) {
+    const { key } = property;
+    if (key.type === AST_NODE_TYPES.Literal) {
+        return key.value === null ? null : String(key.value);
+    }
+    // A computed key still names one property when it is a template without
+    // substitutions; written plainly, an identifier is the name itself.
+    if (key.type === AST_NODE_TYPES.TemplateLiteral) {
+        return key.expressions.length === 0 ? (key.quasis[0]?.value.cooked ?? null) : null;
+    }
+    if (key.type === AST_NODE_TYPES.Identifier) {
+        return property.computed ? null : key.name;
+    }
+    return null;
+}
 export function findClassProperty(node, propertyName) {
     const property = node.body.body.find((member) => member.type === AST_NODE_TYPES.PropertyDefinition &&
-        member.key?.type === AST_NODE_TYPES.Identifier &&
-        member.key.name === propertyName);
+        getPropertyKeyName(member) === propertyName);
     return property?.type === AST_NODE_TYPES.PropertyDefinition ? property : null;
 }
 /**
@@ -90,9 +109,7 @@ export function findNodeDescriptionObject(node) {
     return findConstructorAssignedDescription(node);
 }
 export function findObjectProperty(obj, propertyName) {
-    const property = obj.properties.find((prop) => prop.type === AST_NODE_TYPES.Property &&
-        prop.key.type === AST_NODE_TYPES.Identifier &&
-        prop.key.name === propertyName);
+    const property = obj.properties.find((prop) => prop.type === AST_NODE_TYPES.Property && getPropertyKeyName(prop) === propertyName);
     return property?.type === AST_NODE_TYPES.Property ? property : null;
 }
 export function getLiteralValue(node) {

package/docs/rules/valid-node-categories.md

@@ -0,0 +1,27 @@
+# Require supported community node categories in .node.json codex files (`@n8n/community-nodes/valid-node-categories`)
+
+💼 This rule is enabled in the following configs: ✅ `recommended`, ☑️ `recommendedWithoutN8nCloudSupport`.
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule checks `categories` in community node `.node.json` codex files. Each category must match a value in the [node category list](https://docs.n8n.io/connect/create-nodes/build-your-node/reference/codex-files/#node-categories). The rule also rejects empty arrays and values that are not strings. The `categories` field is optional.
+
+## Examples
+
+### ❌ Incorrect
+
+```json
+{
+  "categories": ["Marketing", "Bananas"]
+}
+```
+
+### ✅ Correct
+
+```json
+{
+  "categories": ["Marketing & Content", "Development"]
+}
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@n8n/eslint-plugin-community-nodes",
   "type": "module",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "main": "./dist/plugin.js",
   "types": "./dist/plugin.d.ts",
   "exports": {
@@ -17,9 +17,9 @@
   },
   "devDependencies": {
     "@n8n/typescript-config": "1.12.0",
-    "@n8n/vitest-config": "1.22.0",
+    "@n8n/vitest-config": "1.23.0",
     "@types/node": "24.10.1",
-    "n8n-workflow": "2.40.0",
+    "n8n-workflow": "2.42.0",
     "@typescript-eslint/rule-tester": "8.70.0",
     "eslint-doc-generator": "^2.2.2",
     "eslint-plugin-eslint-plugin": "^7.0.0",
@@ -27,7 +27,7 @@
     "@typescript/native": "npm:typescript@7.0.2",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "vite": "^8.0.2",
-    "vitest": "^4.1.9"
+    "vitest": "5.0.1"
   },
   "peerDependencies": {
     "eslint": "9.29.0",

package/src/plugin.ts

@@ -61,6 +61,7 @@ const configs = {
 			'@n8n/community-nodes/valid-author': 'error',
 			'@n8n/community-nodes/valid-credential-references': 'error',
 			'@n8n/community-nodes/valid-description': 'error',
+			'@n8n/community-nodes/valid-node-categories': 'error',
 			'@n8n/community-nodes/valid-peer-dependencies': 'error',
 			'@n8n/community-nodes/webhook-lifecycle-complete': 'error',
 		},
@@ -110,6 +111,7 @@ const configs = {
 			'@n8n/community-nodes/valid-author': 'error',
 			'@n8n/community-nodes/valid-credential-references': 'error',
 			'@n8n/community-nodes/valid-description': 'error',
+			'@n8n/community-nodes/valid-node-categories': 'error',
 			'@n8n/community-nodes/valid-peer-dependencies': 'error',
 			'@n8n/community-nodes/webhook-lifecycle-complete': 'error',
 		},

package/src/rules/index.ts

@@ -42,6 +42,7 @@ import { TriggerNodeConventionsRule } from './trigger-node-conventions.js';
 import { ValidAuthorRule } from './valid-author.js';
 import { ValidCredentialReferencesRule } from './valid-credential-references.js';
 import { ValidDescriptionRule } from './valid-description.js';
+import { ValidNodeCategoriesRule } from './valid-node-categories.js';
 import { ValidPeerDependenciesRule } from './valid-peer-dependencies.js';
 import { WebhookLifecycleCompleteRule } from './webhook-lifecycle-complete.js';
 
@@ -88,6 +89,7 @@ export const rules = {
 	'valid-author': ValidAuthorRule,
 	'valid-credential-references': ValidCredentialReferencesRule,
 	'valid-description': ValidDescriptionRule,
+	'valid-node-categories': ValidNodeCategoriesRule,
 	'valid-peer-dependencies': ValidPeerDependenciesRule,
 	'webhook-lifecycle-complete': WebhookLifecycleCompleteRule,
 } satisfies Record<string, AnyRuleModule>;

package/src/rules/no-silent-error-swallowing.test.ts

@@ -174,6 +174,32 @@ export class RegularClass {
 			}`),
 			errors: [{ messageId: 'silentReturn', data: { method: 'delete' } }],
 		},
+		{
+			name: 'lifecycle method written with a computed literal key',
+			code: createTriggerNode(`{
+				default: {
+					['delete']: async function (this: IHookFunctions): Promise<boolean> {
+						try {
+							return await this.helpers.httpRequest({ url: 'https://example.com' });
+						} catch (error) {}
+					},
+				},
+			}`),
+			errors: [{ messageId: 'emptyCatch', data: { method: 'delete' } }],
+		},
+		{
+			name: 'lifecycle group written with a quoted key',
+			code: createTriggerNode(`{
+				'default': {
+					async delete(this: IHookFunctions): Promise<boolean> {
+						try {
+							return await this.helpers.httpRequest({ url: 'https://example.com' });
+						} catch (error) {}
+					},
+				},
+			}`),
+			errors: [{ messageId: 'emptyCatch', data: { method: 'delete' } }],
+		},
 		{
 			name: 'catch block with a bare return',
 			code: createTriggerNode(`{

package/src/rules/no-silent-error-swallowing.ts

@@ -3,20 +3,13 @@ import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
 import {
 	createRule,
 	findClassProperty,
+	getPropertyKeyName,
 	isNodeTypeClass,
 	WEBHOOK_LIFECYCLE_METHODS,
 } from '../utils/index.js';
 
 const LIFECYCLE_METHODS: readonly string[] = WEBHOOK_LIFECYCLE_METHODS;
 
-/** Returns the static name of a non-computed object property key, or null. */
-function getPropertyName(property: TSESTree.Property): string | null {
-	if (property.computed) return null;
-	if (property.key.type === AST_NODE_TYPES.Identifier) return property.key.name;
-	if (property.key.type === AST_NODE_TYPES.Literal) return String(property.key.value);
-	return null;
-}
-
 function isFunctionNode(node: TSESTree.Node): boolean {
 	return (
 		node.type === AST_NODE_TYPES.FunctionDeclaration ||
@@ -81,7 +74,7 @@ export const NoSilentErrorSwallowingRule = createRule({
 					for (const methodProperty of groupProperty.value.properties) {
 						if (methodProperty.type !== AST_NODE_TYPES.Property) continue;
 
-						const methodName = getPropertyName(methodProperty);
+						const methodName = getPropertyKeyName(methodProperty);
 						if (methodName === null || !LIFECYCLE_METHODS.includes(methodName)) continue;
 
 						const fn = methodProperty.value;

package/src/rules/valid-node-categories.test.ts

@@ -0,0 +1,79 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { ValidNodeCategoriesRule } from './valid-node-categories.js';
+
+const ruleTester = new RuleTester();
+const filename = 'nodes/Example/Example.node.json';
+
+function codex(categories: unknown): string {
+	return JSON.stringify({ node: 'n8n-nodes-example', categories });
+}
+
+ruleTester.run('valid-node-categories', ValidNodeCategoriesRule, {
+	valid: [
+		{
+			name: 'all supported community categories',
+			filename,
+			code: codex([
+				'Data & Storage',
+				'Finance & Accounting',
+				'Marketing & Content',
+				'Productivity',
+				'Miscellaneous',
+				'Sales',
+				'Development',
+				'Analytics',
+				'Communication',
+				'Utility',
+			]),
+		},
+		{ name: 'codex without categories', filename, code: '{ "node": "n8n-nodes-example" }' },
+		{
+			name: 'unrelated JSON file',
+			filename: 'package.json',
+			code: codex(['Bananas']),
+		},
+		{
+			name: 'non-node class',
+			filename: 'nodes/Example/Example.node.ts',
+			code: 'class Example { categories = ["Bananas"]; }',
+		},
+		{
+			name: 'nested categories do not count as codex categories',
+			filename,
+			code: '{ "resources": { "categories": ["Bananas"] } }',
+		},
+	],
+	invalid: [
+		{
+			name: 'unknown category',
+			filename,
+			code: codex(['Development', 'Bananas']),
+			errors: [{ messageId: 'invalidCategory', data: { category: 'Bananas' } }],
+		},
+		{
+			name: 'old marketing category',
+			filename,
+			code: codex(['Marketing']),
+			errors: [{ messageId: 'marketingCategory' }],
+		},
+		{
+			name: 'invalid category type',
+			filename,
+			code: codex(['Sales', 12]),
+			errors: [{ messageId: 'invalidCategoryType' }],
+		},
+		{
+			name: 'categories must be an array',
+			filename,
+			code: codex('Sales'),
+			errors: [{ messageId: 'invalidCategories' }],
+		},
+		{
+			name: 'empty categories array',
+			filename,
+			code: codex([]),
+			errors: [{ messageId: 'invalidCategories' }],
+		},
+	],
+});

package/src/rules/valid-node-categories.ts

@@ -0,0 +1,72 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import { createRule, findJsonProperty, getTopLevelObjectInJson } from '../utils/index.js';
+
+const validCategories = new Set([
+	'Data & Storage',
+	'Finance & Accounting',
+	'Marketing & Content',
+	'Productivity',
+	'Miscellaneous',
+	'Sales',
+	'Development',
+	'Analytics',
+	'Communication',
+	'Utility',
+]);
+
+export const ValidNodeCategoriesRule = createRule({
+	name: 'valid-node-categories',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Require supported community node categories in .node.json codex files',
+		},
+		messages: {
+			invalidCategories: '"categories" must be a non-empty array of community node categories.',
+			invalidCategoryType: 'Each category must be a string from the community node category list.',
+			invalidCategory:
+				'"{{ category }}" is not a supported community node category. See https://docs.n8n.io/connect/create-nodes/build-your-node/reference/codex-files/#node-categories for the allowed values.',
+			marketingCategory: '"Marketing" is not a supported category. Use "Marketing & Content".',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!context.filename.endsWith('.node.json')) return {};
+
+		return {
+			ObjectExpression(node: TSESTree.ObjectExpression) {
+				const root = getTopLevelObjectInJson(node);
+				if (!root) return;
+
+				const categories = findJsonProperty(root, 'categories');
+				if (!categories) return;
+
+				if (
+					categories.value.type !== AST_NODE_TYPES.ArrayExpression ||
+					categories.value.elements.length === 0
+				) {
+					context.report({ node: categories.value, messageId: 'invalidCategories' });
+					return;
+				}
+
+				for (const category of categories.value.elements) {
+					if (!category) continue;
+					if (category.type !== AST_NODE_TYPES.Literal || typeof category.value !== 'string') {
+						context.report({ node: category, messageId: 'invalidCategoryType' });
+					} else if (category.value === 'Marketing') {
+						context.report({ node: category, messageId: 'marketingCategory' });
+					} else if (!validCategories.has(category.value)) {
+						context.report({
+							node: category,
+							messageId: 'invalidCategory',
+							data: { category: category.value },
+						});
+					}
+				}
+			},
+		};
+	},
+});

package/src/rules/webhook-lifecycle-complete.test.ts

@@ -88,6 +88,30 @@ export class RegularClass {
 				}`,
 			}),
 		},
+		{
+			name: 'lifecycle methods written with computed literal keys',
+			code: createTriggerNode({
+				webhookMethods: `{
+					default: {
+						['checkExists']: async () => true,
+						['create']: async () => true,
+						[\`delete\`]: async () => true,
+					},
+				}`,
+			}),
+		},
+		{
+			name: 'lifecycle group and methods written with quoted keys',
+			code: createTriggerNode({
+				webhookMethods: `{
+					'default': {
+						'checkExists': async () => true,
+						'create': async () => true,
+						'delete': async () => true,
+					},
+				}`,
+			}),
+		},
 		{
 			name: 'webhook lifecycle defined via arrow functions',
 			code: createTriggerNode({
@@ -189,6 +213,24 @@ export class RegularClass {
 			}),
 			errors: [{ messageId: 'missingWebhookMethods' }],
 		},
+		{
+			name: 'lifecycle method behind a key only known at runtime',
+			code: createTriggerNode({
+				webhookMethods: `{
+					default: {
+						async checkExists() { return true; },
+						async create() { return true; },
+						[methodName]: async () => true,
+					},
+				}`,
+			}),
+			errors: [
+				{
+					messageId: 'missingLifecycleMethod',
+					data: { group: 'default', missing: '`delete`' },
+				},
+			],
+		},
 		{
 			name: 'multiple webhook groups each missing methods',
 			code: createTriggerNode({

package/src/rules/webhook-lifecycle-complete.ts

@@ -4,6 +4,7 @@ import {
 	createRule,
 	findClassProperty,
 	findObjectProperty,
+	getPropertyKeyName,
 	isNodeTypeClass,
 	WEBHOOK_LIFECYCLE_METHODS,
 	type WebhookLifecycleMethod,
@@ -25,12 +26,7 @@ function hasWebhooksDeclared(descriptionValue: TSESTree.ObjectExpression): boole
 /** Returns true when the property defines a (possibly async) method named `name`. */
 function isMethodProperty(property: TSESTree.ObjectLiteralElement, name: string): boolean {
 	if (property.type !== AST_NODE_TYPES.Property) return false;
-	if (property.computed) return false;
-
-	const keyMatches =
-		(property.key.type === AST_NODE_TYPES.Identifier && property.key.name === name) ||
-		(property.key.type === AST_NODE_TYPES.Literal && property.key.value === name);
-	if (!keyMatches) return false;
+	if (getPropertyKeyName(property) !== name) return false;
 
 	return (
 		property.value.type === AST_NODE_TYPES.FunctionExpression ||
@@ -104,12 +100,7 @@ export const WebhookLifecycleCompleteRule = createRule({
 					if (groupProperty.type !== AST_NODE_TYPES.Property) continue;
 					if (groupProperty.value.type !== AST_NODE_TYPES.ObjectExpression) continue;
 
-					const groupName =
-						groupProperty.key.type === AST_NODE_TYPES.Identifier
-							? groupProperty.key.name
-							: groupProperty.key.type === AST_NODE_TYPES.Literal
-								? String(groupProperty.key.value)
-								: 'default';
+					const groupName = getPropertyKeyName(groupProperty) ?? 'default';
 
 					const missing = findMissingMethods(groupProperty.value);
 					if (missing.length === 0) continue;

package/src/utils/ast-utils.ts

@@ -55,6 +55,33 @@ export function isTriggerNode(
 	return hasTriggerGroup(descriptionValue) || isTriggerNodeClass(node);
 }
 
+/**
+ * Returns the name a property key stands for, or null when it is only known at
+ * runtime. `delete`, `'delete'` and `['delete']` all name the same property, so
+ * how the key is written must not decide whether a rule sees it.
+ */
+export function getPropertyKeyName(
+	property: TSESTree.Property | TSESTree.PropertyDefinition | TSESTree.MethodDefinition,
+): string | null {
+	const { key } = property;
+
+	if (key.type === AST_NODE_TYPES.Literal) {
+		return key.value === null ? null : String(key.value);
+	}
+
+	// A computed key still names one property when it is a template without
+	// substitutions; written plainly, an identifier is the name itself.
+	if (key.type === AST_NODE_TYPES.TemplateLiteral) {
+		return key.expressions.length === 0 ? (key.quasis[0]?.value.cooked ?? null) : null;
+	}
+
+	if (key.type === AST_NODE_TYPES.Identifier) {
+		return property.computed ? null : key.name;
+	}
+
+	return null;
+}
+
 export function findClassProperty(
 	node: TSESTree.ClassDeclaration,
 	propertyName: string,
@@ -62,8 +89,7 @@ export function findClassProperty(
 	const property = node.body.body.find(
 		(member) =>
 			member.type === AST_NODE_TYPES.PropertyDefinition &&
-			member.key?.type === AST_NODE_TYPES.Identifier &&
-			member.key.name === propertyName,
+			getPropertyKeyName(member) === propertyName,
 	);
 	return property?.type === AST_NODE_TYPES.PropertyDefinition ? property : null;
 }
@@ -140,10 +166,7 @@ export function findObjectProperty(
 	propertyName: string,
 ): TSESTree.Property | null {
 	const property = obj.properties.find(
-		(prop) =>
-			prop.type === AST_NODE_TYPES.Property &&
-			prop.key.type === AST_NODE_TYPES.Identifier &&
-			prop.key.name === propertyName,
+		(prop) => prop.type === AST_NODE_TYPES.Property && getPropertyKeyName(prop) === propertyName,
 	);
 	return property?.type === AST_NODE_TYPES.Property ? property : null;
 }