eslint-plugin-sfmc 2.6.1 → 3.0.0

package/src/rules/hbs/no-unknown-helper.js

@@ -0,0 +1,79 @@
+import { isHelper, helperNames } from 'handlebars-data';
+
+import { simpleHelperName, isInvocation, closestMatch } from './_shared.js';
+
+/**
+ * Flags Handlebars helper invocations whose name is not part of the Marketing
+ * Cloud Next catalog. The MCN engine is locked down and cannot register custom
+ * helpers, so any unknown helper is reported.
+ *
+ * Mirrors the `handlebars/unknown-helper` diagnostic emitted by
+ * sfmc-language-lsp. A bare `{{foo}}` mustache with no arguments is treated as a
+ * data binding (not a helper) and is not flagged here.
+ */
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Disallow Handlebars helper invocations that are not part of the Marketing Cloud Next catalog',
+            recommended: true,
+        },
+        messages: {
+            unknownHelper:
+                "Unknown Handlebars {{kind}} '{{name}}'. It is not part of the Marketing Cloud Next catalog, and the MCN engine cannot register custom helpers.",
+            unknownHelperSuggest:
+                "Unknown Handlebars {{kind}} '{{name}}'. It is not part of the Marketing Cloud Next catalog, and the MCN engine cannot register custom helpers. Did you mean '{{suggestion}}'?",
+        },
+        schema: [],
+    },
+
+    create(context) {
+        /**
+         * Reports an unknown helper, attaching a "did you mean" suggestion when
+         * a close catalog match exists.
+         *
+         * @param {object} node - The offending AST node.
+         * @param {string} name - The unknown helper name.
+         * @param {boolean} isBlock - True when the node is a block helper.
+         * @returns {void}
+         */
+        function reportUnknown(node, name, isBlock) {
+            const kind = isBlock ? 'block helper' : 'helper';
+            const suggestion = closestMatch(name, helperNames);
+            if (suggestion) {
+                context.report({
+                    node,
+                    messageId: 'unknownHelperSuggest',
+                    data: { kind, name, suggestion },
+                });
+            } else {
+                context.report({ node, messageId: 'unknownHelper', data: { kind, name } });
+            }
+        }
+
+        /**
+         * Checks an inline mustache or subexpression invocation.
+         *
+         * @param {object} node - The AST node.
+         * @returns {void}
+         */
+        function checkInline(node) {
+            const helperName = simpleHelperName(node.path);
+            if (helperName && isInvocation(node) && !isHelper(helperName)) {
+                reportUnknown(node, helperName, false);
+            }
+        }
+
+        return {
+            MustacheStatement: checkInline,
+            SubExpression: checkInline,
+            HbsBlockStatement(node) {
+                const helperName = simpleHelperName(node.path);
+                if (helperName && !isHelper(helperName)) {
+                    reportUnknown(node, helperName, true);
+                }
+            },
+        };
+    },
+};

package/src/rules/hbs/no-unsupported-construct.js

@@ -0,0 +1,70 @@
+import { unsupportedByNodeType } from 'handlebars-data';
+
+import { simpleHelperName } from './_shared.js';
+
+/**
+ * Flags Handlebars constructs that the locked-down Marketing Cloud Next engine
+ * cannot support: partials, partial blocks, decorators, inline partials, and the
+ * handlebars.js-only `{{log}}` debugging helper.
+ *
+ * Mirrors the `handlebars/unsupported-construct` diagnostic emitted by
+ * sfmc-language-lsp.
+ */
+
+/** AST node types that may carry an unsupported construct. */
+const NODE_TYPES = unsupportedByNodeType.keys().toArray();
+
+// The handlebars-data messages contain literal `{{> ...}}`, `{{log}}`, etc. as
+// examples. ESLint treats `{{...}}` in a message template as an interpolation
+// placeholder, so the literal text is passed through a single `{{text}}`
+// placeholder instead of being baked into the template.
+/** messageId per construct id → passthrough template, declared statically. */
+const MESSAGES = Object.fromEntries(
+    unsupportedByNodeType
+        .values()
+        .toArray()
+        .flat()
+        .map((entry) => [entry.id, '{{text}}']),
+);
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Disallow Handlebars constructs unsupported by the Marketing Cloud Next engine (partials, decorators, log)',
+            recommended: true,
+        },
+        messages: MESSAGES,
+        schema: [],
+    },
+
+    create(context) {
+        /**
+         * Reports the first unsupported-construct entry matching a node.
+         *
+         * @param {object} node - The Handlebars AST node.
+         * @returns {void}
+         */
+        function check(node) {
+            const candidates = unsupportedByNodeType.get(node.type);
+            if (!candidates) {
+                return;
+            }
+            const helperName = simpleHelperName(node.path);
+            for (const entry of candidates) {
+                if (entry.helperName !== null && entry.helperName !== helperName) {
+                    continue;
+                }
+                context.report({ node, messageId: entry.id, data: { text: entry.message } });
+                return;
+            }
+        }
+
+        const visitors = {};
+        for (const nodeType of NODE_TYPES) {
+            visitors[nodeType] = check;
+        }
+        return visitors;
+    },
+};

package/src/rules/ssjs/cache-loop-length.js

@@ -34,23 +34,23 @@ export default {
                     return;
                 }
 
-                let lengthExpr = null;
+                let lengthExpression = null;
                 if (containsMemberLength(test.right)) {
-                    lengthExpr = test.right;
+                    lengthExpression = test.right;
                 } else if (containsMemberLength(test.left)) {
-                    lengthExpr = test.left;
+                    lengthExpression = test.left;
                 }
 
-                if (!lengthExpr) {
+                if (!lengthExpression) {
                     return;
                 }
 
-                const fix = buildCacheFix(node, lengthExpr, context);
+                const fix = buildCacheFix(node, lengthExpression, context);
 
                 context.report({
                     node: test,
                     messageId: 'cacheLength',
-                    ...(fix ? { fix } : {}),
+                    ...(fix && { fix }),
                 });
             },
         };
@@ -61,17 +61,14 @@ function containsMemberLength(node) {
     if (!node) {
         return false;
     }
-    if (
+    return (
         node.type === 'MemberExpression' &&
         node.property.type === 'Identifier' &&
         node.property.name === 'length'
-    ) {
-        return true;
-    }
-    return false;
+    );
 }
 
-function buildCacheFix(forNode, lengthExpr, context) {
+function buildCacheFix(forNode, lengthExpression, context) {
     const init = forNode.init;
     // Only fix when init is a VariableDeclaration so we can safely
     // append a new declarator without restructuring the loop header.
@@ -79,14 +76,14 @@ function buildCacheFix(forNode, lengthExpr, context) {
         return null;
     }
 
-    const objText = context.sourceCode.getText(lengthExpr.object);
-    const lenVar = '_len';
+    const objectText = context.sourceCode.getText(lengthExpression.object);
+    const lengthVariable = '_len';
 
     return function fix(fixer) {
-        const lastDecl = init.declarations.at(-1);
+        const lastDeclaration = init.declarations.at(-1);
         return [
-            fixer.insertTextAfter(lastDecl, `, ${lenVar} = ${objText}.length`),
-            fixer.replaceText(lengthExpr, lenVar),
+            fixer.insertTextAfter(lastDeclaration, `, ${lengthVariable} = ${objectText}.length`),
+            fixer.replaceText(lengthExpression, lengthVariable),
         ];
     };
 }

package/src/rules/ssjs/no-deprecated-function.js

@@ -62,20 +62,20 @@ export default {
 
         return {
             VariableDeclaration(node) {
-                for (const decl of node.declarations) {
+                for (const declaration of node.declarations) {
                     if (
-                        decl.init &&
-                        decl.id &&
-                        decl.id.type === 'Identifier' &&
-                        isContentAreaObjInit(decl.init)
+                        declaration.init &&
+                        declaration.id &&
+                        declaration.id.type === 'Identifier' &&
+                        isContentAreaObjectInit(declaration.init)
                     ) {
-                        contentAreaVariables.add(decl.id.name);
+                        contentAreaVariables.add(declaration.id.name);
                     }
                 }
             },
 
             AssignmentExpression(node) {
-                if (node.left.type === 'Identifier' && isContentAreaObjInit(node.right)) {
+                if (node.left.type === 'Identifier' && isContentAreaObjectInit(node.right)) {
                     contentAreaVariables.add(node.left.name);
                 }
             },
@@ -166,7 +166,7 @@ export default {
  * @param {import('eslint').Rule.Node} node - AST node to inspect
  * @returns {boolean} true when the node is a ContentAreaObj.Init call
  */
-function isContentAreaObjInit(node) {
+function isContentAreaObjectInit(node) {
     if (!node || node.type !== 'CallExpression') {
         return false;
     }

package/src/rules/ssjs/no-hardcoded-credentials.js

@@ -29,9 +29,7 @@ export default {
             CallExpression(node) {
                 const callee = node.callee;
 
-                let functionName = null;
-
-                if (
+                const functionName =
                     callee.type === 'MemberExpression' &&
                     callee.object.type === 'MemberExpression' &&
                     callee.object.object.type === 'Identifier' &&
@@ -39,9 +37,8 @@ export default {
                     callee.object.property.type === 'Identifier' &&
                     callee.object.property.name === 'Function' &&
                     callee.property.type === 'Identifier'
-                ) {
-                    functionName = callee.property.name;
-                }
+                        ? callee.property.name
+                        : null;
 
                 if (!functionName || !ENCRYPT_FUNCTIONS.has(functionName.toLowerCase())) {
                     return;

package/src/rules/ssjs/no-property-call.js

@@ -38,10 +38,7 @@ function canReplaceCallWithAssignment(node) {
     if (parent.type === 'ExpressionStatement' && parent.expression === node) {
         return true;
     }
-    if (parent.type === 'SequenceExpression' && parent.expressions.includes(node)) {
-        return true;
-    }
-    return false;
+    return Boolean(parent.type === 'SequenceExpression' && parent.expressions.includes(node));
 }
 
 export default {
@@ -83,11 +80,11 @@ export default {
                 }
 
                 const ns = callee.object.property.name.toLowerCase();
-                const propName = callee.property.name.toLowerCase();
+                const propertyName = callee.property.name.toLowerCase();
                 const displayNs = callee.object.property.name;
                 const displayName = callee.property.name;
 
-                if (ns === 'response' && RESPONSE_PROPERTIES.has(propName)) {
+                if (ns === 'response' && RESPONSE_PROPERTIES.has(propertyName)) {
                     if (node.arguments.length === 0) {
                         context.report({
                             node,
@@ -106,10 +103,10 @@ export default {
                                 if (!canReplaceCallWithAssignment(node)) {
                                     return null;
                                 }
-                                const argText = sourceCode.getText(node.arguments[0]);
+                                const argumentText = sourceCode.getText(node.arguments[0]);
                                 return fixer.replaceText(
                                     node,
-                                    `${sourceCode.getText(callee)} = ${argText}`,
+                                    `${sourceCode.getText(callee)} = ${argumentText}`,
                                 );
                             },
                         });
@@ -120,7 +117,7 @@ export default {
                             data: { ns: displayNs, name: displayName },
                         });
                     }
-                } else if (ns === 'request' && REQUEST_PROPERTIES.has(propName)) {
+                } else if (ns === 'request' && REQUEST_PROPERTIES.has(propertyName)) {
                     if (node.arguments.length === 0) {
                         context.report({
                             node,

package/src/rules/ssjs/no-treatascontent-injection.js

@@ -35,9 +35,9 @@ export default {
                     return;
                 }
 
-                const arg = node.arguments[0];
-                if (containsConcatenation(arg)) {
-                    context.report({ node: arg, messageId: 'injection' });
+                const argument = node.arguments[0];
+                if (containsConcatenation(argument)) {
+                    context.report({ node: argument, messageId: 'injection' });
                 }
             },
         };
@@ -53,7 +53,7 @@ function isTreatAsContentCall(node) {
     }
 
     // Platform.Function.TreatAsContent(...)
-    if (
+    return (
         callee.type === 'MemberExpression' &&
         callee.property.type === 'Identifier' &&
         callee.property.name === 'TreatAsContent' &&
@@ -62,19 +62,12 @@ function isTreatAsContentCall(node) {
         callee.object.property.name === 'Function' &&
         callee.object.object.type === 'Identifier' &&
         callee.object.object.name === 'Platform'
-    ) {
-        return true;
-    }
-
-    return false;
+    );
 }
 
 function containsConcatenation(node) {
     if (node.type === 'BinaryExpression' && node.operator === '+') {
         return true;
     }
-    if (node.type === 'TemplateLiteral' && node.expressions.length > 0) {
-        return true;
-    }
-    return false;
+    return node.type === 'TemplateLiteral' && node.expressions.length > 0;
 }

package/src/rules/ssjs/no-unavailable-method.js

@@ -98,8 +98,8 @@ export default {
 
         function buildSuggestFix(entry) {
             return function fix(fixer) {
-                const src = context.sourceCode;
-                const end = src.ast.range[1];
+                const source = context.sourceCode;
+                const end = source.ast.range[1];
                 return fixer.insertTextAfterRange([end, end], '\n\n' + entry.polyfill);
             };
         }
@@ -113,27 +113,27 @@ export default {
                     return;
                 }
 
-                const obj = left.object;
-                const prop = left.property;
-                if (prop.type !== 'Identifier') {
+                const object = left.object;
+                const property = left.property;
+                if (property.type !== 'Identifier') {
                     return;
                 }
 
                 // Array.X = ...
-                if (obj.type === 'Identifier' && obj.name === 'Array') {
-                    alreadyPolyfilled.add(prop.name);
+                if (object.type === 'Identifier' && object.name === 'Array') {
+                    alreadyPolyfilled.add(property.name);
                     return;
                 }
 
                 // Array.prototype.X = ...  or  String.prototype.X = ...
                 if (
-                    obj.type === 'MemberExpression' &&
-                    obj.object.type === 'Identifier' &&
-                    (obj.object.name === 'Array' || obj.object.name === 'String') &&
-                    obj.property.type === 'Identifier' &&
-                    obj.property.name === 'prototype'
+                    object.type === 'MemberExpression' &&
+                    object.object.type === 'Identifier' &&
+                    (object.object.name === 'Array' || object.object.name === 'String') &&
+                    object.property.type === 'Identifier' &&
+                    object.property.name === 'prototype'
                 ) {
-                    alreadyPolyfilled.add(prop.name);
+                    alreadyPolyfilled.add(property.name);
                 }
             },
 
@@ -143,12 +143,12 @@ export default {
                     return;
                 }
 
-                const prop = callee.property;
-                if (prop.type !== 'Identifier') {
+                const property = callee.property;
+                if (property.type !== 'Identifier') {
                     return;
                 }
 
-                const methodName = prop.name;
+                const methodName = property.name;
                 const receiver = callee.object;
 
                 const lowerMethod = methodName.toLowerCase();
@@ -163,7 +163,7 @@ export default {
                         return;
                     }
                     const entry = polyfillByStaticName.get(methodName);
-                    pendingReports.push({ node: prop, entry });
+                    pendingReports.push({ node: property, entry });
                     return;
                 }
 
@@ -176,7 +176,7 @@ export default {
                     const entry = knownUnsupportedByStaticName.get(lowerMethod);
                     const ownerBase = entry.owner.replace(/\.prototype$/, '');
                     if (receiver.name === ownerBase && !ignored.has(methodName)) {
-                        pendingReports.push({ node: prop, entry, noPolyfill: true });
+                        pendingReports.push({ node: property, entry, noPolyfill: true });
                         return;
                     }
                 }
@@ -187,13 +187,13 @@ export default {
                         return;
                     }
 
-                    const entry = polyfillByPrototypeName.get(methodName);
-
                     // Skip known SFMC top-level objects to avoid false positives.
                     if (receiver.type === 'Identifier' && SFMC_RECEIVERS.has(receiver.name)) {
                         return;
                     }
 
+                    const entry = polyfillByPrototypeName.get(methodName);
+
                     // For methods that also exist on String.prototype in ES3
                     // (indexOf, lastIndexOf), only flag when the receiver is
                     // a literal array or the call is chained from an array method
@@ -211,7 +211,7 @@ export default {
                         }
                     }
 
-                    pendingReports.push({ node: prop, entry });
+                    pendingReports.push({ node: property, entry });
                     return;
                 }
 
@@ -225,7 +225,7 @@ export default {
                         return;
                     }
                     const entry = knownUnsupportedByPrototypeName.get(lowerMethod);
-                    pendingReports.push({ node: prop, entry, noPolyfill: true });
+                    pendingReports.push({ node: property, entry, noPolyfill: true });
                 }
             },
 

package/src/rules/ssjs/no-unknown-function.js

@@ -70,7 +70,7 @@ export default {
 
     create(context) {
         const options = context.options[0] ?? {};
-        const targetNext = options.target === 'next';
+        const isTargetNext = options.target === 'next';
 
         // Track variable name → Core Library type name (assigned via TypeName.Init())
         const coreVariables = new Map();
@@ -79,16 +79,20 @@ export default {
 
         return {
             VariableDeclaration(node) {
-                for (const decl of node.declarations) {
-                    if (!decl.init || !decl.id || decl.id.type !== 'Identifier') {
+                for (const declaration of node.declarations) {
+                    if (
+                        !declaration.init ||
+                        !declaration.id ||
+                        declaration.id.type !== 'Identifier'
+                    ) {
                         continue;
                     }
-                    const coreType = getCoreInitType(decl.init);
+                    const coreType = getCoreInitType(declaration.init);
                     if (coreType) {
-                        coreVariables.set(decl.id.name, coreType);
+                        coreVariables.set(declaration.id.name, coreType);
                     }
-                    if (isWSProxyConstructor(decl.init)) {
-                        wsproxyVariables.add(decl.id.name);
+                    if (isWSProxyConstructor(declaration.init)) {
+                        wsproxyVariables.add(declaration.id.name);
                     }
                 }
             },
@@ -119,7 +123,7 @@ export default {
                 const methodName = property.name;
 
                 // ── MCN target: flag all SSJS API calls as unsupported ────────
-                if (targetNext) {
+                if (isTargetNext) {
                     // Only report on Platform.<NS>.<method>(), HTTP.<method>(),
                     // Core Library instance calls, or WSProxy calls — not bare JS.
                     const isPlatformCall =
@@ -189,10 +193,10 @@ export default {
                     // Core library: var de = DataExtension.Init("key"); de.Foo();
                     const coreType = coreVariables.get(objectName);
                     if (coreType) {
-                        const objectDef = coreObjectLookup.get(coreType);
-                        if (objectDef) {
+                        const objectDefinition = coreObjectLookup.get(coreType);
+                        if (objectDefinition) {
                             const knownMethods = new Set(
-                                objectDef.methods.map((m) => m.toLowerCase()),
+                                objectDefinition.methods.map((m) => m.toLowerCase()),
                             );
                             if (!knownMethods.has(methodName.toLowerCase())) {
                                 context.report({
@@ -201,7 +205,7 @@ export default {
                                     data: {
                                         method: methodName,
                                         objectType: coreType,
-                                        available: objectDef.methods.join(', '),
+                                        available: objectDefinition.methods.join(', '),
                                     },
                                 });
                             }

package/src/rules/ssjs/no-unsupported-syntax.js

@@ -21,8 +21,8 @@ const AUTO_FIX = {
 
 function nullishCoalescingFix(context, node) {
     return (fixer) => {
-        const src = context.sourceCode.getText();
-        const between = src.slice(node.left.range[1], node.right.range[0]);
+        const source = context.sourceCode.getText();
+        const between = source.slice(node.left.range[1], node.right.range[0]);
         const offset = between.indexOf('??');
         if (offset === -1) {
             return null;
@@ -34,9 +34,9 @@ function nullishCoalescingFix(context, node) {
 
 function directObjectReturnFix(context, node) {
     return (fixer) => {
-        const objText = context.sourceCode.getText(node.argument);
+        const objectText = context.sourceCode.getText(node.argument);
         const indent = ' '.repeat(node.loc.start.column);
-        return fixer.replaceText(node, `var _result = ${objText};\n${indent}return _result;`);
+        return fixer.replaceText(node, `var _result = ${objectText};\n${indent}return _result;`);
     };
 }
 
@@ -92,7 +92,7 @@ export default {
                         },
                     };
 
-                    if (entry.feature in AUTO_FIX) {
+                    if (Object.hasOwn(AUTO_FIX, entry.feature)) {
                         report.fix = AUTO_FIX[entry.feature](node);
                     } else if (entry.feature === 'NullishCoalescing') {
                         report.fix = nullishCoalescingFix(context, node);

package/src/rules/ssjs/{prefer-parsejson-safe-arg.js → prefer-parsejson-safe-argument.js}

@@ -34,19 +34,19 @@ export default {
                     return;
                 }
 
-                const arg = node.arguments[0];
+                const argument = node.arguments[0];
 
-                if (isAlreadySafe(arg)) {
+                if (isAlreadySafe(argument)) {
                     return;
                 }
 
                 context.report({
-                    node: arg,
+                    node: argument,
                     messageId: 'unsafeArg',
-                    data: { argText: context.sourceCode.getText(arg) },
+                    data: { argText: context.sourceCode.getText(argument) },
                     fix(fixer) {
-                        const argText = context.sourceCode.getText(arg);
-                        return fixer.replaceText(arg, `${argText} + ''`);
+                        const argumentText = context.sourceCode.getText(argument);
+                        return fixer.replaceText(argument, `${argumentText} + ''`);
                     },
                 });
             },
@@ -63,7 +63,7 @@ function isParseJSONCall(node) {
     }
 
     // Platform.Function.ParseJSON(...)
-    if (
+    return (
         callee.type === 'MemberExpression' &&
         callee.property.type === 'Identifier' &&
         callee.property.name === 'ParseJSON' &&
@@ -72,29 +72,21 @@ function isParseJSONCall(node) {
         callee.object.property.name === 'Function' &&
         callee.object.object.type === 'Identifier' &&
         callee.object.object.name === 'Platform'
-    ) {
-        return true;
-    }
-
-    return false;
+    );
 }
 
-function isAlreadySafe(arg) {
+function isAlreadySafe(argument) {
     // arg + ''  or  '' + arg
     if (
-        arg.type === 'BinaryExpression' &&
-        arg.operator === '+' &&
-        (isEmptyString(arg.left) || isEmptyString(arg.right))
+        argument.type === 'BinaryExpression' &&
+        argument.operator === '+' &&
+        (isEmptyString(argument.left) || isEmptyString(argument.right))
     ) {
         return true;
     }
 
     // String literal passed directly — already a string
-    if (arg.type === 'Literal' && typeof arg.value === 'string') {
-        return true;
-    }
-
-    return false;
+    return argument.type === 'Literal' && typeof argument.value === 'string';
 }
 
 function isEmptyString(node) {