@n8n/eslint-plugin-community-nodes 0.36.0 → 0.38.0

package/README.md

@@ -77,6 +77,7 @@ export default [
 | [node-connection-type-literal](docs/rules/node-connection-type-literal.md)               | Disallow string literals in node description `inputs`/`outputs` — use `NodeConnectionTypes` enum instead                                                                               | ✅ ☑️ |      | 🔧 |    |    |
 | [node-registration-complete](docs/rules/node-registration-complete.md)                   | Ensure every `.node.ts` file in the `nodes/` directory is registered in the "n8n.nodes" array of package.json                                                                          |      | ✅ ☑️ |    |    |    |
 | [node-usable-as-tool](docs/rules/node-usable-as-tool.md)                                 | Ensure node classes have usableAsTool property                                                                                                                                         | ✅ ☑️ |      | 🔧 |    |    |
+| [open-ended-node-fields](docs/rules/open-ended-node-fields.md)                           | Discourage optional open-ended JSON fields in node properties                                                                                                                          |      | ✅ ☑️ |    |    |    |
 | [package-name-convention](docs/rules/package-name-convention.md)                         | Enforce correct package naming convention for n8n community nodes                                                                                                                      | ✅ ☑️ |      |    | 💡 |    |
 | [require-files-array](docs/rules/require-files-array.md)                                 | Require a non-empty "files" array in package.json                                                                                                                                      |      | ✅ ☑️ |    |    |    |
 | [require-homepage](docs/rules/require-homepage.md)                                       | Require a "homepage" field with a valid URL in package.json                                                                                                                            |      | ✅ ☑️ |    |    |    |

package/dist/plugin.d.ts

@@ -23,6 +23,7 @@ declare const configs: {
             '@n8n/community-nodes/no-deprecated-workflow-functions': "error";
             '@n8n/community-nodes/no-emoji-in-options': "error";
             '@n8n/community-nodes/node-usable-as-tool': "error";
+            '@n8n/community-nodes/open-ended-node-fields': "warn";
             '@n8n/community-nodes/package-name-convention': "error";
             '@n8n/community-nodes/credential-test-required': "error";
             '@n8n/community-nodes/no-credential-reuse': "error";
@@ -80,6 +81,7 @@ declare const configs: {
             '@n8n/community-nodes/no-deprecated-workflow-functions': "error";
             '@n8n/community-nodes/no-emoji-in-options': "error";
             '@n8n/community-nodes/node-usable-as-tool': "error";
+            '@n8n/community-nodes/open-ended-node-fields': "warn";
             '@n8n/community-nodes/package-name-convention': "error";
             '@n8n/community-nodes/credential-test-required': "error";
             '@n8n/community-nodes/no-credential-reuse': "error";
@@ -148,6 +150,7 @@ declare const pluginWithConfigs: {
                 '@n8n/community-nodes/no-deprecated-workflow-functions': "error";
                 '@n8n/community-nodes/no-emoji-in-options': "error";
                 '@n8n/community-nodes/node-usable-as-tool': "error";
+                '@n8n/community-nodes/open-ended-node-fields': "warn";
                 '@n8n/community-nodes/package-name-convention': "error";
                 '@n8n/community-nodes/credential-test-required': "error";
                 '@n8n/community-nodes/no-credential-reuse': "error";
@@ -205,6 +208,7 @@ declare const pluginWithConfigs: {
                 '@n8n/community-nodes/no-deprecated-workflow-functions': "error";
                 '@n8n/community-nodes/no-emoji-in-options': "error";
                 '@n8n/community-nodes/node-usable-as-tool': "error";
+                '@n8n/community-nodes/open-ended-node-fields': "warn";
                 '@n8n/community-nodes/package-name-convention': "error";
                 '@n8n/community-nodes/credential-test-required': "error";
                 '@n8n/community-nodes/no-credential-reuse': "error";
@@ -274,6 +278,7 @@ declare const n8nCommunityNodesPlugin: {
                 '@n8n/community-nodes/no-deprecated-workflow-functions': "error";
                 '@n8n/community-nodes/no-emoji-in-options': "error";
                 '@n8n/community-nodes/node-usable-as-tool': "error";
+                '@n8n/community-nodes/open-ended-node-fields': "warn";
                 '@n8n/community-nodes/package-name-convention': "error";
                 '@n8n/community-nodes/credential-test-required': "error";
                 '@n8n/community-nodes/no-credential-reuse': "error";
@@ -331,6 +336,7 @@ declare const n8nCommunityNodesPlugin: {
                 '@n8n/community-nodes/no-deprecated-workflow-functions': "error";
                 '@n8n/community-nodes/no-emoji-in-options': "error";
                 '@n8n/community-nodes/node-usable-as-tool': "error";
+                '@n8n/community-nodes/open-ended-node-fields': "warn";
                 '@n8n/community-nodes/package-name-convention': "error";
                 '@n8n/community-nodes/credential-test-required': "error";
                 '@n8n/community-nodes/no-credential-reuse': "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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA4DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDgB,CAAC;AAE1C,QAAA,MAAM,iBAAiB;;QAnHrB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA4DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD+C,CAAC;AAEzE,QAAA,MAAM,uBAAuB;;QArH3B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA4DpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDwB,CAAC;eACnC,iBAAiB;AAChC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/plugin.js

@@ -25,6 +25,7 @@ const configs = {
             '@n8n/community-nodes/no-deprecated-workflow-functions': 'error',
             '@n8n/community-nodes/no-emoji-in-options': 'error',
             '@n8n/community-nodes/node-usable-as-tool': 'error',
+            '@n8n/community-nodes/open-ended-node-fields': 'warn',
             '@n8n/community-nodes/package-name-convention': 'error',
             '@n8n/community-nodes/credential-test-required': 'error',
             '@n8n/community-nodes/no-credential-reuse': 'error',
@@ -75,6 +76,7 @@ const configs = {
             '@n8n/community-nodes/no-deprecated-workflow-functions': 'error',
             '@n8n/community-nodes/no-emoji-in-options': 'error',
             '@n8n/community-nodes/node-usable-as-tool': 'error',
+            '@n8n/community-nodes/open-ended-node-fields': 'warn',
             '@n8n/community-nodes/package-name-convention': 'error',
             '@n8n/community-nodes/credential-test-required': 'error',
             '@n8n/community-nodes/no-credential-reuse': 'error',

package/dist/rules/index.d.ts

@@ -20,6 +20,9 @@ export declare const rules: {
     'node-usable-as-tool': import("@typescript-eslint/utils/ts-eslint").RuleModule<"aiOnlyUsableAsTool" | "missingUsableAsTool" | "triggerUsableAsTool", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    'open-ended-node-fields': import("@typescript-eslint/utils/ts-eslint").RuleModule<"optionalJson", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
     'package-name-convention': import("@typescript-eslint/utils/ts-eslint").RuleModule<"defaultPlaceholderName" | "invalidPackageName" | "missingName" | "renameTo", [], 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":"AAgDA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAiDA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CuB,CAAC"}

package/dist/rules/index.js

@@ -29,6 +29,7 @@ import { NodeClassDescriptionIconMissingRule } from './node-class-description-ic
 import { NodeConnectionTypeLiteralRule } from './node-connection-type-literal.js';
 import { NodeRegistrationCompleteRule } from './node-registration-complete.js';
 import { NodeUsableAsToolRule } from './node-usable-as-tool.js';
+import { OpenEndedNodeFieldsRule } from './open-ended-node-fields.js';
 import { PackageNameConventionRule } from './package-name-convention.js';
 import { RequireFilesArrayRule } from './require-files-array.js';
 import { RequireHomepageRule } from './require-homepage.js';
@@ -51,6 +52,7 @@ export const rules = {
     'no-deprecated-workflow-functions': NoDeprecatedWorkflowFunctionsRule,
     'no-emoji-in-options': NoEmojiInOptionsRule,
     'node-usable-as-tool': NodeUsableAsToolRule,
+    'open-ended-node-fields': OpenEndedNodeFieldsRule,
     'package-name-convention': PackageNameConventionRule,
     'credential-test-required': CredentialTestRequiredRule,
     'credential-unnecessary-password': CredentialUnnecessaryPasswordRule,

package/dist/rules/no-deprecated-workflow-functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-deprecated-workflow-functions.d.ts","sourceRoot":"","sources":["../../src/rules/no-deprecated-workflow-functions.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,iCAAiC;;CA6I5C,CAAC"}
+{"version":3,"file":"no-deprecated-workflow-functions.d.ts","sourceRoot":"","sources":["../../src/rules/no-deprecated-workflow-functions.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,iCAAiC;;CA0J5C,CAAC"}

package/dist/rules/no-deprecated-workflow-functions.js

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import { createRule, isThisHelpersAccess } from '../utils/index.js';
+import { createRule, isHelpersAccess, isThisHelpersAccess, EXECUTION_CONTEXT_TYPES, } from '../utils/index.js';
 const DEPRECATED_FUNCTIONS = {
     request: 'httpRequest',
     requestWithAuthentication: 'httpRequestWithAuthentication',
@@ -38,21 +38,32 @@ export const NoDeprecatedWorkflowFunctionsRule = createRule({
     defaultOptions: [],
     create(context) {
         const n8nWorkflowTypes = new Set();
-        return {
-            ImportDeclaration(node) {
-                if (node.source.value === 'n8n-workflow') {
-                    node.specifiers.forEach((specifier) => {
-                        if (specifier.type === AST_NODE_TYPES.ImportSpecifier &&
-                            specifier.imported.type === AST_NODE_TYPES.Identifier) {
-                            n8nWorkflowTypes.add(specifier.local.name);
-                        }
-                    });
+        let importsExecutionContext = false;
+        // Collect n8n-workflow imports up front. ESLint visits nodes in source order, so a
+        // `helpers` access above its import statement would otherwise be checked before the
+        // import is seen.
+        for (const statement of context.sourceCode.ast.body) {
+            if (statement.type !== AST_NODE_TYPES.ImportDeclaration ||
+                statement.source.value !== 'n8n-workflow') {
+                continue;
+            }
+            for (const specifier of statement.specifiers) {
+                if (specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+                    specifier.imported.type === AST_NODE_TYPES.Identifier) {
+                    n8nWorkflowTypes.add(specifier.local.name);
+                    if (EXECUTION_CONTEXT_TYPES.has(specifier.imported.name)) {
+                        importsExecutionContext = true;
+                    }
                 }
-            },
+            }
+        }
+        return {
             MemberExpression(node) {
                 if (node.property.type === AST_NODE_TYPES.Identifier &&
                     isDeprecatedFunctionName(node.property.name)) {
-                    if (!isThisHelpersAccess(node)) {
+                    // `this.helpers` is unambiguous on its own; any other receiver only counts in a file
+                    // that imports an execution context type, which is what makes its `helpers` n8n's.
+                    if (!isThisHelpersAccess(node) && !(importsExecutionContext && isHelpersAccess(node))) {
                         return;
                     }
                     const functionName = node.property.name;

package/dist/rules/open-ended-node-fields.d.ts

@@ -0,0 +1,4 @@
+export declare const OpenEndedNodeFieldsRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"optionalJson", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+//# sourceMappingURL=open-ended-node-fields.d.ts.map

package/dist/rules/open-ended-node-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-ended-node-fields.d.ts","sourceRoot":"","sources":["../../src/rules/open-ended-node-fields.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,uBAAuB;;CAyClC,CAAC"}

package/dist/rules/open-ended-node-fields.js

@@ -0,0 +1,44 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createRule, findArrayLiteralProperty, findNodeDescriptionObject, findObjectProperty, getBooleanLiteralValue, getStringLiteralValue, isFileType, isNodeTypeClass, } from '../utils/index.js';
+export const OpenEndedNodeFieldsRule = createRule({
+    name: 'open-ended-node-fields',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Discourage optional open-ended JSON fields in node properties',
+        },
+        messages: {
+            optionalJson: 'Optional JSON fields can hide configuration. Use typed parameters under Additional Options or Additional Fields instead.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        if (!isFileType(context.filename, '.node.ts'))
+            return {};
+        return {
+            ClassDeclaration(node) {
+                if (!isNodeTypeClass(node))
+                    return;
+                const description = findNodeDescriptionObject(node);
+                if (!description)
+                    return;
+                const properties = findArrayLiteralProperty(description, 'properties');
+                if (!properties)
+                    return;
+                for (const property of properties.elements) {
+                    if (property?.type !== AST_NODE_TYPES.ObjectExpression)
+                        continue;
+                    const type = findObjectProperty(property, 'type');
+                    if (getStringLiteralValue(type?.value ?? null) !== 'json')
+                        continue;
+                    const required = findObjectProperty(property, 'required');
+                    if (getBooleanLiteralValue(required?.value ?? null) === true)
+                        continue;
+                    context.report({ node: property, messageId: 'optionalJson' });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=open-ended-node-fields.js.map

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

@@ -45,6 +45,14 @@ export declare function extractCredentialNameFromArray(element: TSESTree.ArrayEx
 } | null;
 /** Matches the `this.helpers` MemberExpression (the object part of `this.helpers.foo`). */
 export declare function isThisHelpersAccess(node: TSESTree.MemberExpression): boolean;
+/** Execution context interfaces from `n8n-workflow` that expose a `helpers` object. */
+export declare const EXECUTION_CONTEXT_TYPES: Set<string>;
+/**
+ * Matches `<receiver>.helpers.<method>` for any receiver, and a bare `helpers.<method>` left by
+ * destructuring. Deliberately does not identify the receiver: the rule runs without type
+ * information, so callers gate this on the file importing an execution context type instead.
+ */
+export declare function isHelpersAccess(node: TSESTree.MemberExpression): boolean;
 /** Matches a call expression of the form `this.methodName(...)`. */
 export declare function isThisMethodCall(node: TSESTree.CallExpression, method: string): boolean;
 /** Matches a call expression of the form `this.helpers.methodName(...)`. */

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

@@ -219,6 +219,33 @@ export function isThisHelpersAccess(node) {
         node.object.property?.type === AST_NODE_TYPES.Identifier &&
         node.object.property.name === 'helpers');
 }
+/** Execution context interfaces from `n8n-workflow` that expose a `helpers` object. */
+export const EXECUTION_CONTEXT_TYPES = new Set([
+    'IAllExecuteFunctions',
+    'ICredentialTestFunctions',
+    'IExecuteFunctions',
+    'IExecutePaginationFunctions',
+    'IExecuteSingleFunctions',
+    'IHookFunctions',
+    'ILoadOptionsFunctions',
+    'IPollFunctions',
+    'ISupplyDataFunctions',
+    'ITriggerFunctions',
+    'IWebhookFunctions',
+]);
+/**
+ * Matches `<receiver>.helpers.<method>` for any receiver, and a bare `helpers.<method>` left by
+ * destructuring. Deliberately does not identify the receiver: the rule runs without type
+ * information, so callers gate this on the file importing an execution context type instead.
+ */
+export function isHelpersAccess(node) {
+    if (node.object.type === AST_NODE_TYPES.Identifier) {
+        return node.object.name === 'helpers';
+    }
+    return (node.object.type === AST_NODE_TYPES.MemberExpression &&
+        node.object.property.type === AST_NODE_TYPES.Identifier &&
+        node.object.property.name === 'helpers');
+}
 /** Matches a call expression of the form `this.methodName(...)`. */
 export function isThisMethodCall(node, method) {
     return (node.callee.type === AST_NODE_TYPES.MemberExpression &&

package/dist/utils/credential-fields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"credential-fields.d.ts","sourceRoot":"","sources":["../../src/utils/credential-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAkBpD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GACvD,OAAO,CAST;AAED,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC,gBAAgB,GAAG,OAAO,CAWjF"}
+{"version":3,"file":"credential-fields.d.ts","sourceRoot":"","sources":["../../src/utils/credential-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAmBpD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GACvD,OAAO,CAST;AAED,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC,gBAAgB,GAAG,OAAO,CAWjF"}

package/dist/utils/credential-fields.js

@@ -7,6 +7,7 @@ const SENSITIVE_PATTERNS = [
     'cert',
     'passphrase',
     'apikey',
+    'accesskey',
     'secretkey',
     'privatekey',
     'authkey',

package/docs/rules/no-deprecated-workflow-functions.md

@@ -10,6 +10,26 @@
 
 Prevents usage of deprecated functions from n8n-workflow package and suggests modern alternatives.
 
+A node reaches these helpers through its execution context, which it can hold in
+several ways — all of them are reported:
+
+```typescript
+this.helpers.request(options); // execute() bound to the context
+context.helpers.requestOAuth2.call(context, 'oAuth2Api', options); // context passed into a transport helper
+this.executeFunctions.helpers.request(options); // context stored on a class field
+const { helpers } = this;
+helpers.request(options); // destructured off the context, reported on the call
+```
+
+> [!NOTE]
+> The rule runs without type information, so it cannot tell which object a
+> `helpers` property belongs to. Apart from `this.helpers`, it therefore only
+> reports in files that import an execution context interface
+> (`IExecuteFunctions`, `ILoadOptionsFunctions`, …) from `n8n-workflow`. The
+> check is file-scoped rather than binding-scoped: in such a file, an unrelated
+> `someClient.helpers.request()` would also be reported. Silence the rare false
+> positive with `// eslint-disable-next-line`.
+
 ## Examples
 
 ### ❌ Incorrect

package/docs/rules/open-ended-node-fields.md

@@ -0,0 +1,35 @@
+# Discourage optional open-ended JSON fields in node properties (`@n8n/community-nodes/open-ended-node-fields`)
+
+⚠️ This rule _warns_ in the following configs: ✅ `recommended`, ☑️ `recommendedWithoutN8nCloudSupport`.
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule warns about optional top-level JSON properties in node descriptions. A JSON configuration field can hide parameters from the editor. Typed parameters make configuration easier to find, validate, and change.
+
+Place optional parameters under Additional Options or Additional Fields. The rule does not report required JSON properties or typed collection options.
+
+## Examples
+
+### Incorrect
+
+```typescript
+properties: [
+	{ displayName: 'Configuration', name: 'configuration', type: 'json', default: '{}' },
+];
+```
+
+### Correct
+
+```typescript
+properties: [
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		default: {},
+		options: [{ displayName: 'Limit', name: 'limit', type: 'number', default: 10 }],
+	},
+];
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@n8n/eslint-plugin-community-nodes",
   "type": "module",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "main": "./dist/plugin.js",
   "types": "./dist/plugin.d.ts",
   "exports": {
@@ -11,7 +11,7 @@
     }
   },
   "dependencies": {
-    "@n8n/utils": "1.51.0",
+    "@n8n/utils": "1.53.0",
     "@typescript-eslint/typescript-estree": "8.70.0",
     "@typescript-eslint/utils": "8.70.0",
     "fastest-levenshtein": "1.0.16"
@@ -20,14 +20,14 @@
     "@n8n/typescript-config": "1.12.0",
     "@n8n/vitest-config": "1.24.0",
     "@types/node": "24.10.1",
-    "n8n-workflow": "2.44.0",
+    "n8n-workflow": "2.46.0",
     "@typescript-eslint/rule-tester": "8.70.0",
     "eslint-doc-generator": "^2.2.2",
     "eslint-plugin-eslint-plugin": "^7.0.0",
     "rimraf": "6.0.1",
     "@typescript/native": "npm:typescript@7.0.2",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "vite": "^8.0.2",
+    "vite": "^8.1.6",
     "vitest": "5.0.1"
   },
   "peerDependencies": {

package/src/plugin.ts

@@ -29,6 +29,7 @@ const configs = {
 			'@n8n/community-nodes/no-deprecated-workflow-functions': 'error',
 			'@n8n/community-nodes/no-emoji-in-options': 'error',
 			'@n8n/community-nodes/node-usable-as-tool': 'error',
+			'@n8n/community-nodes/open-ended-node-fields': 'warn',
 			'@n8n/community-nodes/package-name-convention': 'error',
 			'@n8n/community-nodes/credential-test-required': 'error',
 			'@n8n/community-nodes/no-credential-reuse': 'error',
@@ -79,6 +80,7 @@ const configs = {
 			'@n8n/community-nodes/no-deprecated-workflow-functions': 'error',
 			'@n8n/community-nodes/no-emoji-in-options': 'error',
 			'@n8n/community-nodes/node-usable-as-tool': 'error',
+			'@n8n/community-nodes/open-ended-node-fields': 'warn',
 			'@n8n/community-nodes/package-name-convention': 'error',
 			'@n8n/community-nodes/credential-test-required': 'error',
 			'@n8n/community-nodes/no-credential-reuse': 'error',

package/src/rules/credential-password-field.test.ts

@@ -166,6 +166,12 @@ ruleTester.run('credential-password-field', CredentialPasswordFieldRule, {
 			errors: [{ messageId: 'missingPasswordOption', data: { fieldName: 'apiKey' } }],
 			output: createCredentialCode([createProperty('API Key', 'apiKey', { password: true })]),
 		},
+		{
+			name: 'access key field missing typeOptions.password = true',
+			code: createCredentialCode([createProperty('Access Key', 'accessKey')]),
+			errors: [{ messageId: 'missingPasswordOption', data: { fieldName: 'accessKey' } }],
+			output: createCredentialCode([createProperty('Access Key', 'accessKey', { password: true })]),
+		},
 		{
 			name: 'secret field missing typeOptions.password = true',
 			code: createCredentialCode([createProperty('Client Secret', 'clientSecret')]),

package/src/rules/index.ts

@@ -31,6 +31,7 @@ import { NodeClassDescriptionIconMissingRule } from './node-class-description-ic
 import { NodeConnectionTypeLiteralRule } from './node-connection-type-literal.js';
 import { NodeRegistrationCompleteRule } from './node-registration-complete.js';
 import { NodeUsableAsToolRule } from './node-usable-as-tool.js';
+import { OpenEndedNodeFieldsRule } from './open-ended-node-fields.js';
 import { PackageNameConventionRule } from './package-name-convention.js';
 import { RequireFilesArrayRule } from './require-files-array.js';
 import { RequireHomepageRule } from './require-homepage.js';
@@ -54,6 +55,7 @@ export const rules = {
 	'no-deprecated-workflow-functions': NoDeprecatedWorkflowFunctionsRule,
 	'no-emoji-in-options': NoEmojiInOptionsRule,
 	'node-usable-as-tool': NodeUsableAsToolRule,
+	'open-ended-node-fields': OpenEndedNodeFieldsRule,
 	'package-name-convention': PackageNameConventionRule,
 	'credential-test-required': CredentialTestRequiredRule,
 	'credential-unnecessary-password': CredentialUnnecessaryPasswordRule,

package/src/rules/no-deprecated-workflow-functions.test.ts

@@ -47,6 +47,17 @@ import { IRequestOptions } from 'some-other-package';
 
 function test(options: IRequestOptions) {
 	return options.url;
+}`,
+		},
+		{
+			name: 'non-this helpers in a file that does not handle execution contexts',
+			code: `
+import { SomeApiClient } from 'some-other-package';
+
+function makeRequest(client: SomeApiClient) {
+	const { helpers } = client;
+	helpers.request('https://example.com');
+	return client.helpers.request('https://example.com');
 }`,
 		},
 	],
@@ -183,5 +194,216 @@ return this.helpers.prepareOutputData([{ json: response }]);`,
 				},
 			],
 		},
+		{
+			name: 'execution context passed in as a parameter',
+			code: `
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+export async function apiRequest(context: IExecuteFunctions, options) {
+	return await context.helpers.requestOAuth2.call(context, 'exampleOAuth2Api', options);
+}`,
+			errors: [
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: { functionName: 'requestOAuth2', replacement: 'httpRequestWithAuthentication' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: { functionName: 'requestOAuth2', replacement: 'httpRequestWithAuthentication' },
+							output: `
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+export async function apiRequest(context: IExecuteFunctions, options) {
+	return await context.helpers.httpRequestWithAuthentication.call(context, 'exampleOAuth2Api', options);
+}`,
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'execution context union type parameter',
+			code: `
+import type { IExecuteFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
+
+async function loadOptions(ctx: IExecuteFunctions | ILoadOptionsFunctions) {
+	return await ctx.helpers.request({ url: 'https://example.com' });
+}`,
+			errors: [
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: { functionName: 'request', replacement: 'httpRequest' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: { functionName: 'request', replacement: 'httpRequest' },
+							output: `
+import type { IExecuteFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
+
+async function loadOptions(ctx: IExecuteFunctions | ILoadOptionsFunctions) {
+	return await ctx.helpers.httpRequest({ url: 'https://example.com' });
+}`,
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'helpers destructured from this',
+			code: `
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+async function run(this: IExecuteFunctions) {
+	const { helpers } = this;
+	return await helpers.requestWithAuthentication('exampleApi', options);
+}`,
+			errors: [
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: {
+						functionName: 'requestWithAuthentication',
+						replacement: 'httpRequestWithAuthentication',
+					},
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: {
+								functionName: 'requestWithAuthentication',
+								replacement: 'httpRequestWithAuthentication',
+							},
+							output: `
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+async function run(this: IExecuteFunctions) {
+	const { helpers } = this;
+	return await helpers.httpRequestWithAuthentication('exampleApi', options);
+}`,
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'execution context held in a class field',
+			code: `
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+class ExampleApi {
+	private executeFunctions: IExecuteFunctions;
+
+	async request(options) {
+		return await this.executeFunctions.helpers.requestWithAuthentication.call(
+			this.executeFunctions,
+			'exampleApi',
+			options,
+		);
+	}
+}`,
+			errors: [
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: {
+						functionName: 'requestWithAuthentication',
+						replacement: 'httpRequestWithAuthentication',
+					},
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: {
+								functionName: 'requestWithAuthentication',
+								replacement: 'httpRequestWithAuthentication',
+							},
+							output: `
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+class ExampleApi {
+	private executeFunctions: IExecuteFunctions;
+
+	async request(options) {
+		return await this.executeFunctions.helpers.httpRequestWithAuthentication.call(
+			this.executeFunctions,
+			'exampleApi',
+			options,
+		);
+	}
+}`,
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'execution context declared as a constructor parameter property',
+			code: `
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+class ExampleApi {
+	constructor(private readonly ctx: IExecuteFunctions) {}
+
+	async run() {
+		return await this.ctx.helpers.prepareOutputData([]);
+	}
+}`,
+			errors: [
+				{
+					messageId: 'deprecatedWithoutReplacement',
+					data: { functionName: 'prepareOutputData' },
+				},
+			],
+		},
+		{
+			name: 'execution context used above its import statement',
+			code: `
+async function apiRequest(context: IExecuteFunctions, options) {
+	return await context.helpers.request(options);
+}
+
+import type { IExecuteFunctions } from 'n8n-workflow';`,
+			errors: [
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: { functionName: 'request', replacement: 'httpRequest' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: { functionName: 'request', replacement: 'httpRequest' },
+							output: `
+async function apiRequest(context: IExecuteFunctions, options) {
+	return await context.helpers.httpRequest(options);
+}
+
+import type { IExecuteFunctions } from 'n8n-workflow';`,
+						},
+					],
+				},
+			],
+		},
+		{
+			name: 'credential test context passed in as a parameter',
+			code: `
+import type { ICredentialTestFunctions } from 'n8n-workflow';
+
+export async function testCredential(context: ICredentialTestFunctions, options) {
+	return await context.helpers.request(options);
+}`,
+			errors: [
+				{
+					messageId: 'deprecatedRequestFunction',
+					data: { functionName: 'request', replacement: 'httpRequest' },
+					suggestions: [
+						{
+							messageId: 'suggestReplaceFunction',
+							data: { functionName: 'request', replacement: 'httpRequest' },
+							output: `
+import type { ICredentialTestFunctions } from 'n8n-workflow';
+
+export async function testCredential(context: ICredentialTestFunctions, options) {
+	return await context.helpers.httpRequest(options);
+}`,
+						},
+					],
+				},
+			],
+		},
 	],
 });

package/src/rules/no-deprecated-workflow-functions.ts

@@ -1,6 +1,11 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-import { createRule, isThisHelpersAccess } from '../utils/index.js';
+import {
+	createRule,
+	isHelpersAccess,
+	isThisHelpersAccess,
+	EXECUTION_CONTEXT_TYPES,
+} from '../utils/index.js';
 
 const DEPRECATED_FUNCTIONS = {
 	request: 'httpRequest',
@@ -46,27 +51,40 @@ export const NoDeprecatedWorkflowFunctionsRule = createRule({
 	defaultOptions: [],
 	create(context) {
 		const n8nWorkflowTypes = new Set<string>();
-
-		return {
-			ImportDeclaration(node) {
-				if (node.source.value === 'n8n-workflow') {
-					node.specifiers.forEach((specifier) => {
-						if (
-							specifier.type === AST_NODE_TYPES.ImportSpecifier &&
-							specifier.imported.type === AST_NODE_TYPES.Identifier
-						) {
-							n8nWorkflowTypes.add(specifier.local.name);
-						}
-					});
+		let importsExecutionContext = false;
+
+		// Collect n8n-workflow imports up front. ESLint visits nodes in source order, so a
+		// `helpers` access above its import statement would otherwise be checked before the
+		// import is seen.
+		for (const statement of context.sourceCode.ast.body) {
+			if (
+				statement.type !== AST_NODE_TYPES.ImportDeclaration ||
+				statement.source.value !== 'n8n-workflow'
+			) {
+				continue;
+			}
+			for (const specifier of statement.specifiers) {
+				if (
+					specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+					specifier.imported.type === AST_NODE_TYPES.Identifier
+				) {
+					n8nWorkflowTypes.add(specifier.local.name);
+					if (EXECUTION_CONTEXT_TYPES.has(specifier.imported.name)) {
+						importsExecutionContext = true;
+					}
 				}
-			},
+			}
+		}
 
+		return {
 			MemberExpression(node) {
 				if (
 					node.property.type === AST_NODE_TYPES.Identifier &&
 					isDeprecatedFunctionName(node.property.name)
 				) {
-					if (!isThisHelpersAccess(node)) {
+					// `this.helpers` is unambiguous on its own; any other receiver only counts in a file
+					// that imports an execution context type, which is what makes its `helpers` n8n's.
+					if (!isThisHelpersAccess(node) && !(importsExecutionContext && isHelpersAccess(node))) {
 						return;
 					}
 

package/src/rules/open-ended-node-fields.test.ts

@@ -0,0 +1,122 @@
+import { Linter } from 'eslint';
+import { describe, expect, it } from 'vitest';
+
+import { configs } from '../plugin.js';
+
+const linter = new Linter();
+
+function createNodeCode(property: string): string {
+	return `
+export class TestNode extends Node {
+	description = {
+		displayName: 'Test Node',
+		name: 'testNode',
+		group: ['transform'],
+		version: 1,
+		inputs: ['main'],
+		outputs: ['main'],
+		properties: [${property}],
+	};
+}`;
+}
+
+function lintNode(code: string, config: keyof typeof configs) {
+	return linter.verify(code, [{ ...configs[config], files: ['**/*.node.ts'] }], {
+		filename: 'src/rules/TestNode.node.ts',
+	});
+}
+
+describe.each(['recommended', 'recommendedWithoutN8nCloudSupport'] as const)(
+	'%s node property review',
+	(config) => {
+		// CE-1879: Warn when an optional JSON field replaces typed node parameters.
+		it('warns about an optional JSON configuration catch-all', () => {
+			const code = createNodeCode(`{
+				displayName: 'Configuration',
+				name: 'configuration',
+				type: 'json',
+				required: false,
+				default: '{}',
+			}`);
+
+			const warnings = lintNode(code, config).filter(
+				({ severity, message }) => severity === 1 && /Additional (Options|Fields)/i.test(message),
+			);
+
+			expect(warnings).toEqual([
+				expect.objectContaining({
+					severity: 1,
+					message: expect.stringMatching(/Additional (Options|Fields)/i),
+				}),
+			]);
+		});
+
+		it('does not warn about typed parameters inside Additional Fields', () => {
+			const code = createNodeCode(`{
+				displayName: 'Additional Fields',
+				name: 'additionalFields',
+				type: 'collection',
+				default: {},
+				options: [{ displayName: 'Limit', name: 'limit', type: 'number', default: 10 }],
+			}`);
+
+			const messages = lintNode(code, config);
+			expect(messages).toEqual(
+				expect.arrayContaining([
+					expect.objectContaining({
+						ruleId: '@n8n/community-nodes/require-node-description-fields',
+					}),
+				]),
+			);
+
+			const warnings = messages.filter(
+				({ severity, message }) => severity === 1 && /Additional (Options|Fields)/i.test(message),
+			);
+
+			expect(warnings).toEqual([]);
+		});
+
+		it('warns when an open-ended JSON field does not declare required', () => {
+			const code = createNodeCode(`{
+				displayName: 'Configuration',
+				name: 'configuration',
+				type: 'json',
+				default: '{}',
+			}`);
+
+			expect(
+				lintNode(code, config).filter(
+					({ ruleId }) => ruleId === '@n8n/community-nodes/open-ended-node-fields',
+				),
+			).toHaveLength(1);
+		});
+
+		it('does not warn about required JSON fields', () => {
+			const code = createNodeCode(`{
+				displayName: 'Request Body',
+				name: 'body',
+				type: 'json',
+				required: true,
+				default: '{}',
+			}`);
+
+			expect(
+				lintNode(code, config).filter(
+					({ ruleId }) => ruleId === '@n8n/community-nodes/open-ended-node-fields',
+				),
+			).toEqual([]);
+		});
+
+		it('does not inspect classes that are not nodes', () => {
+			const code = `class Helper {
+				description = { properties: [{ type: 'json', required: false }] };
+			}`;
+
+			expect(
+				lintNode(code, config).filter(
+					({ ruleId }) => ruleId === '@n8n/community-nodes/open-ended-node-fields',
+				),
+			).toEqual([]);
+		});
+	},
+);

package/src/rules/open-ended-node-fields.ts

@@ -0,0 +1,55 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import {
+	createRule,
+	findArrayLiteralProperty,
+	findNodeDescriptionObject,
+	findObjectProperty,
+	getBooleanLiteralValue,
+	getStringLiteralValue,
+	isFileType,
+	isNodeTypeClass,
+} from '../utils/index.js';
+
+export const OpenEndedNodeFieldsRule = createRule({
+	name: 'open-ended-node-fields',
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Discourage optional open-ended JSON fields in node properties',
+		},
+		messages: {
+			optionalJson:
+				'Optional JSON fields can hide configuration. Use typed parameters under Additional Options or Additional Fields instead.',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		if (!isFileType(context.filename, '.node.ts')) return {};
+
+		return {
+			ClassDeclaration(node) {
+				if (!isNodeTypeClass(node)) return;
+
+				const description = findNodeDescriptionObject(node);
+				if (!description) return;
+
+				const properties = findArrayLiteralProperty(description, 'properties');
+				if (!properties) return;
+
+				for (const property of properties.elements) {
+					if (property?.type !== AST_NODE_TYPES.ObjectExpression) continue;
+
+					const type = findObjectProperty(property, 'type');
+					if (getStringLiteralValue(type?.value ?? null) !== 'json') continue;
+
+					const required = findObjectProperty(property, 'required');
+					if (getBooleanLiteralValue(required?.value ?? null) === true) continue;
+
+					context.report({ node: property, messageId: 'optionalJson' });
+				}
+			},
+		};
+	},
+});

package/src/utils/ast-utils.ts

@@ -327,6 +327,38 @@ export function isThisHelpersAccess(node: TSESTree.MemberExpression): boolean {
 	);
 }
 
+/** Execution context interfaces from `n8n-workflow` that expose a `helpers` object. */
+export const EXECUTION_CONTEXT_TYPES = new Set([
+	'IAllExecuteFunctions',
+	'ICredentialTestFunctions',
+	'IExecuteFunctions',
+	'IExecutePaginationFunctions',
+	'IExecuteSingleFunctions',
+	'IHookFunctions',
+	'ILoadOptionsFunctions',
+	'IPollFunctions',
+	'ISupplyDataFunctions',
+	'ITriggerFunctions',
+	'IWebhookFunctions',
+]);
+
+/**
+ * Matches `<receiver>.helpers.<method>` for any receiver, and a bare `helpers.<method>` left by
+ * destructuring. Deliberately does not identify the receiver: the rule runs without type
+ * information, so callers gate this on the file importing an execution context type instead.
+ */
+export function isHelpersAccess(node: TSESTree.MemberExpression): boolean {
+	if (node.object.type === AST_NODE_TYPES.Identifier) {
+		return node.object.name === 'helpers';
+	}
+
+	return (
+		node.object.type === AST_NODE_TYPES.MemberExpression &&
+		node.object.property.type === AST_NODE_TYPES.Identifier &&
+		node.object.property.name === 'helpers'
+	);
+}
+
 /** Matches a call expression of the form `this.methodName(...)`. */
 export function isThisMethodCall(node: TSESTree.CallExpression, method: string): boolean {
 	return (

package/src/utils/credential-fields.ts

@@ -9,6 +9,7 @@ const SENSITIVE_PATTERNS = [
 	'cert',
 	'passphrase',
 	'apikey',
+	'accesskey',
 	'secretkey',
 	'privatekey',
 	'authkey',