eslint-plugin-sfmc 1.0.2 → 2.1.0

package/src/rules/amp/function-arity.js

@@ -1,5 +1,96 @@
 import { functionLookup } from 'ampscript-data';
 
+/**
+ * Reads a numeric-literal argument value from an AMPscript AST argument node.
+ * Returns the integer when the argument is a positive integer literal, otherwise null.
+ *
+ * @param {object} argument - AMPscript argument AST node.
+ * @returns {number | null} The integer value, or null when it is not a usable literal.
+ */
+function readIntLiteral(argument) {
+    if (!argument) {
+        return null;
+    }
+    // NumberLiteral / StringLiteral nodes both carry the raw value as a string.
+    if (argument.type === 'NumberLiteral' || argument.type === 'StringLiteral') {
+        const n = Number(argument.value);
+        return Number.isInteger(n) && n >= 0 ? n : null;
+    }
+    return null;
+}
+
+/**
+ * Validates the repeating-group structure of a variadic AMPscript call.
+ * Returns a messageId + data object when the trailing arguments do not form
+ * complete repeating groups, otherwise null.
+ *
+ * @param {object} entry - ampscript-data function entry (with `repeat`).
+ * @param {object[]} args - the call's argument AST nodes.
+ * @returns {{messageId: string, data: object} | null} Violation descriptor or null.
+ */
+function checkRepeatGroups(entry, args) {
+    const groups = entry.repeat;
+    if (!Array.isArray(groups) || groups.length === 0) {
+        return null;
+    }
+    const actual = args.length;
+
+    // Single repeating group: trailing args must be a whole multiple of groupSize.
+    if (groups.length === 1) {
+        const { startIndex, groupSize, minGroups } = groups[0];
+        if (actual <= startIndex) {
+            // not enough args even to start the group; minArgs check handles "too few"
+            return minGroups > 0 && actual < startIndex + groupSize * minGroups
+                ? incompleteGroup(entry, groupSize)
+                : null;
+        }
+        const trailing = actual - startIndex;
+        if (trailing % groupSize !== 0) {
+            return incompleteGroup(entry, groupSize);
+        }
+        if (trailing / groupSize < minGroups) {
+            return incompleteGroup(entry, groupSize);
+        }
+        return null;
+    }
+
+    // Two repeating groups (DataExtension Update/Upsert family): the first group's
+    // size is dictated by a countParam literal; the second group fills the rest.
+    const [g1, g2] = groups;
+    const countArg = g1.countParam
+        ? readIntLiteral(args[entry.params.findIndex((p) => p.name === g1.countParam)])
+        : null;
+
+    if (countArg === null) {
+        // countParam is not a literal we can evaluate; fall back to a parity check:
+        // every trailing arg pair must be even across both groups.
+        const trailing = actual - g1.startIndex;
+        return trailing % g1.groupSize === 0 ? null : incompleteGroup(entry, g1.groupSize);
+    }
+
+    const group1Args = countArg * g1.groupSize;
+    const group2Start = g1.startIndex + group1Args;
+    const group2Count = actual - group2Start;
+    if (group2Count <= 0 || group2Count % g2.groupSize !== 0) {
+        return incompleteGroup(entry, g2.groupSize);
+    }
+    return null;
+}
+
+/**
+ * Builds the incompleteGroup report descriptor.
+ *
+ * @param {object} entry - ampscript-data function entry.
+ * @param {number} groupSize - size of the repeating unit that is incomplete.
+ * @returns {{messageId: string, data: object}} Report descriptor.
+ */
+function incompleteGroup(entry, groupSize) {
+    return {
+        messageId: 'incompleteGroup',
+        data: { name: entry.name, size: String(groupSize) },
+    };
+}
+
 export default {
     meta: {
         type: 'problem',
@@ -12,6 +103,8 @@ export default {
                 "'{{name}}' requires at least {{min}} argument(s) but was called with {{actual}}.",
             tooManyArgs:
                 "'{{name}}' accepts at most {{max}} argument(s) but was called with {{actual}}.",
+            incompleteGroup:
+                "'{{name}}' expects its repeating arguments in complete groups of {{size}}.",
         },
         schema: [],
     },
@@ -36,7 +129,9 @@ export default {
                             actual: String(actual),
                         },
                     });
-                } else if (actual > entry.maxArgs) {
+                    return;
+                }
+                if (actual > entry.maxArgs) {
                     context.report({
                         node,
                         messageId: 'tooManyArgs',
@@ -46,6 +141,12 @@ export default {
                             actual: String(actual),
                         },
                     });
+                    return;
+                }
+
+                const groupViolation = checkRepeatGroups(entry, node.arguments);
+                if (groupViolation) {
+                    context.report({ node, ...groupViolation });
                 }
             },
         };

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

@@ -4,9 +4,9 @@
  * Flags usage of deprecated AMPscript functions and suggests their
  * modern replacements.
  *
- * For 1:1 replacements (e.g. InsertDE -> InsertData) an auto-fix is provided.
- * For ambiguous replacements (e.g. ContentArea -> ContentBlockByKey OR
- * ContentBlockByName) two manual suggestions are offered instead.
+ * Deprecation metadata is read inline from the FUNCTIONS catalog via the
+ * `deprecatedReplacement` and `deprecatedReason` fields. A 1:1 auto-fix is
+ * provided for each deprecated function.
  */
 
 import { deprecatedFunctionLookup } from 'ampscript-data';
@@ -39,40 +39,22 @@ export default {
                     return;
                 }
 
-                const report = {
+                const replacement = entry.deprecatedReplacement;
+
+                context.report({
                     node,
                     messageId: 'deprecated',
                     data: {
                         name: functionName,
-                        replacement: entry.replacement,
-                        reason: entry.reason,
+                        replacement,
+                        reason: entry.deprecatedReason,
                     },
-                };
-
-                // Replacement strings that contain " or " have multiple options —
-                // offer them as manual suggestions rather than a single auto-fix.
-                const isMulti = entry.replacement.includes(' or ');
-
-                if (isMulti) {
-                    const options = entry.replacement.split(' or ').map((s) => s.trim());
-                    report.suggest = options.map((opt) => ({
-                        messageId: 'replaceWith',
-                        data: { name: functionName, replacement: opt },
-                        fix: (fixer) =>
-                            fixer.replaceTextRange(
-                                [node.range[0], node.range[0] + functionName.length],
-                                opt,
-                            ),
-                    }));
-                } else {
-                    report.fix = (fixer) =>
+                    fix: (fixer) =>
                         fixer.replaceTextRange(
                             [node.range[0], node.range[0] + functionName.length],
-                            entry.replacement,
-                        );
-                }
-
-                context.report(report);
+                            replacement,
+                        ),
+                });
             },
         };
     },

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

@@ -1,4 +1,4 @@
-import { functionNames } from 'ampscript-data';
+import { functionNames, isMcnSupported } from 'ampscript-data';
 
 export default {
     meta: {
@@ -11,19 +11,47 @@ export default {
         messages: {
             unknownFunction:
                 "'{{name}}' is not a recognized AMPscript function. AMPscript does not support custom functions.",
+            notSupportedInMcn: "'{{name}}' is not supported in Marketing Cloud Next.",
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    target: {
+                        type: 'string',
+                        enum: ['engagement', 'next'],
+                        description:
+                            "Target platform. Set to 'next' to additionally flag functions not available in Marketing Cloud Next.",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
     },
 
     create(context) {
+        const options = context.options[0] ?? {};
+        const targetNext = options.target === 'next';
+
         return {
             FunctionCall(node) {
-                if (!functionNames.has(node.name.toLowerCase())) {
+                const lower = node.name.toLowerCase();
+
+                if (!functionNames.has(lower)) {
                     context.report({
                         node,
                         messageId: 'unknownFunction',
                         data: { name: node.name },
                     });
+                    return;
+                }
+
+                if (targetNext && !isMcnSupported(lower)) {
+                    context.report({
+                        node,
+                        messageId: 'notSupportedInMcn',
+                        data: { name: node.name },
+                    });
                 }
             },
         };

package/src/rules/amp/require-variable-declaration.js

@@ -11,6 +11,7 @@
 export default {
     meta: {
         type: 'suggestion',
+        fixable: 'code',
         docs: {
             description: 'Require variables to be declared with `var` before use',
             recommended: false,
@@ -24,6 +25,7 @@ export default {
 
     create(context) {
         const declared = new Set();
+        const fixedVars = new Set();
 
         return {
             VarDeclaration(node) {
@@ -40,11 +42,20 @@ export default {
                 if (name.startsWith('@@')) {
                     return;
                 }
-                if (!declared.has(name.toLowerCase())) {
+                const lower = name.toLowerCase();
+                if (!declared.has(lower)) {
+                    const isFirstFix = !fixedVars.has(lower);
+                    if (isFirstFix) {
+                        fixedVars.add(lower);
+                    }
+
                     context.report({
                         node: node.target,
                         messageId: 'undeclared',
                         data: { name },
+                        fix: isFirstFix
+                            ? (fixer) => fixer.insertTextBefore(node, `var ${name}\n`)
+                            : undefined,
                     });
                 }
             },

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

@@ -7,23 +7,21 @@
  * Bad:  for (var i = 0; i < arr.length; i++)
  * Good: for (var i = 0, _len = arr.length; i < _len; i++)
  *
- * Suggestion: when the for-loop init is a VariableDeclaration (the common
- * case), the suggestion appends `, _len = arr.length` to the declarator
- * list and replaces `arr.length` with `_len` in the test expression.
+ * Auto-fix: when the for-loop init is a VariableDeclaration (the common
+ * case), appends `, _len = arr.length` to the declarator list and replaces
+ * `arr.length` with `_len` in the test expression.
  */
 
 export default {
     meta: {
         type: 'suggestion',
-        hasSuggestions: true,
+        fixable: 'code',
         docs: {
             description: 'Require caching array length in for-loop conditions',
         },
         messages: {
             cacheLength:
                 "Cache '.length' in a variable to avoid re-evaluation on each iteration (e.g. `for (var i = 0, _len = arr.length; i < _len; i++)`).",
-            suggestCacheLength:
-                'Cache .length in a variable (e.g. add `, _len = {{obj}}.length` to the init and replace `{{obj}}.length` with `_len` in the condition)',
         },
         schema: [],
     },
@@ -47,10 +45,12 @@ export default {
                     return;
                 }
 
+                const fix = buildCacheFix(node, lengthExpr, context);
+
                 context.report({
                     node: test,
                     messageId: 'cacheLength',
-                    suggest: buildCacheSuggestion(node, lengthExpr, context),
+                    ...(fix ? { fix } : {}),
                 });
             },
         };
@@ -71,28 +71,22 @@ function containsMemberLength(node) {
     return false;
 }
 
-function buildCacheSuggestion(forNode, lengthExpr, context) {
+function buildCacheFix(forNode, lengthExpr, context) {
     const init = forNode.init;
-    // Only suggest when init is a VariableDeclaration so we can safely
+    // Only fix when init is a VariableDeclaration so we can safely
     // append a new declarator without restructuring the loop header.
     if (!init || init.type !== 'VariableDeclaration' || init.declarations.length === 0) {
-        return [];
+        return null;
     }
 
     const objText = context.sourceCode.getText(lengthExpr.object);
     const lenVar = '_len';
 
-    return [
-        {
-            messageId: 'suggestCacheLength',
-            data: { obj: objText },
-            fix(fixer) {
-                const lastDecl = init.declarations.at(-1);
-                return [
-                    fixer.insertTextAfter(lastDecl, `, ${lenVar} = ${objText}.length`),
-                    fixer.replaceText(lengthExpr, lenVar),
-                ];
-            },
-        },
-    ];
+    return function fix(fixer) {
+        const lastDecl = init.declarations.at(-1);
+        return [
+            fixer.insertTextAfter(lastDecl, `, ${lenVar} = ${objText}.length`),
+            fixer.replaceText(lengthExpr, lenVar),
+        ];
+    };
 }

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

@@ -19,16 +19,31 @@
 
 import { PLATFORM_RESPONSE_METHODS, PLATFORM_REQUEST_METHODS } from 'ssjs-data';
 
-// Platform.Response properties — readable AND writable
 const RESPONSE_PROPERTIES = new Set(
     PLATFORM_RESPONSE_METHODS.filter((m) => m.isProperty).map((m) => m.name.toLowerCase()),
 );
 
-// Platform.Request properties — read-only
 const REQUEST_PROPERTIES = new Set(
     PLATFORM_REQUEST_METHODS.filter((m) => m.isProperty).map((m) => m.name.toLowerCase()),
 );
 
+/**
+ * Returns true when replacing a call with an assignment expression is syntactically safe.
+ *
+ * @param {import('eslint').Rule.Node} node - CallExpression node
+ * @returns {boolean} Whether assignment replacement is valid in this parent context
+ */
+function canReplaceCallWithAssignment(node) {
+    const parent = node.parent;
+    if (parent.type === 'ExpressionStatement' && parent.expression === node) {
+        return true;
+    }
+    if (parent.type === 'SequenceExpression' && parent.expressions.includes(node)) {
+        return true;
+    }
+    return false;
+}
+
 export default {
     meta: {
         type: 'problem',
@@ -56,7 +71,6 @@ export default {
             CallExpression(node) {
                 const callee = node.callee;
 
-                // Must be Platform.<NS>.<property>()
                 if (
                     callee.type !== 'MemberExpression' ||
                     callee.object.type !== 'MemberExpression' ||
@@ -75,7 +89,6 @@ export default {
 
                 if (ns === 'response' && RESPONSE_PROPERTIES.has(propName)) {
                     if (node.arguments.length === 0) {
-                        // Reading with parens — remove ()
                         context.report({
                             node,
                             messageId: 'propertyReadWithCall',
@@ -85,14 +98,12 @@ export default {
                             },
                         });
                     } else if (node.arguments.length === 1) {
-                        // Setting via function call — convert to assignment
                         context.report({
                             node,
                             messageId: 'writablePropertySet',
                             data: { ns: displayNs, name: displayName },
                             fix(fixer) {
-                                // Only safe when the call is a standalone expression statement
-                                if (node.parent.type !== 'ExpressionStatement') {
+                                if (!canReplaceCallWithAssignment(node)) {
                                     return null;
                                 }
                                 const argText = sourceCode.getText(node.arguments[0]);
@@ -103,7 +114,6 @@ export default {
                             },
                         });
                     } else {
-                        // >1 args — unusual, flag without a fix
                         context.report({
                             node,
                             messageId: 'writablePropertySet',
@@ -112,7 +122,6 @@ export default {
                     }
                 } else if (ns === 'request' && REQUEST_PROPERTIES.has(propName)) {
                     if (node.arguments.length === 0) {
-                        // Reading with parens — remove ()
                         context.report({
                             node,
                             messageId: 'propertyReadWithCall',
@@ -122,7 +131,6 @@ export default {
                             },
                         });
                     } else {
-                        // Attempting to set a read-only property — no fix
                         context.report({
                             node,
                             messageId: 'readOnlyPropertySet',

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

@@ -49,11 +49,29 @@ export default {
             unknownCoreMethod:
                 "'{{method}}' is not a known method of {{objectType}}. Available methods: {{available}}.",
             unknownWsproxyMethod: "'{{name}}' is not a recognized WSProxy method.",
+            ssjsNotSupportedInMcn:
+                'SSJS is not supported in Marketing Cloud Next. Use AMPscript instead.',
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    target: {
+                        type: 'string',
+                        enum: ['engagement', 'next'],
+                        description:
+                            "Target platform. Set to 'next' to flag all SSJS API calls as unsupported in Marketing Cloud Next.",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
     },
 
     create(context) {
+        const options = context.options[0] ?? {};
+        const targetNext = options.target === 'next';
+
         // Track variable name → Core Library type name (assigned via TypeName.Init())
         const coreVariables = new Map();
         // Track variable names assigned via new Script.Util.WSProxy()
@@ -100,6 +118,36 @@ export default {
 
                 const methodName = property.name;
 
+                // ── MCN target: flag all SSJS API calls as unsupported ────────
+                if (targetNext) {
+                    // Only report on Platform.<NS>.<method>(), HTTP.<method>(),
+                    // Core Library instance calls, or WSProxy calls — not bare JS.
+                    const isPlatformCall =
+                        callee.object.type === 'MemberExpression' &&
+                        callee.object.object.type === 'Identifier' &&
+                        callee.object.object.name === 'Platform';
+                    const isHttpCall =
+                        callee.object.type === 'Identifier' && callee.object.name === 'HTTP';
+
+                    // Traverse the object chain to find the root identifier
+                    // (handles de.Rows.Retrieve() where root is `de`)
+                    let rootNode = callee.object;
+                    while (rootNode.type === 'MemberExpression') {
+                        rootNode = rootNode.object;
+                    }
+                    const isInstanceCall =
+                        rootNode.type === 'Identifier' &&
+                        (coreVariables.has(rootNode.name) || wsproxyVariables.has(rootNode.name));
+
+                    if (isPlatformCall || isHttpCall || isInstanceCall) {
+                        context.report({
+                            node: property,
+                            messageId: 'ssjsNotSupportedInMcn',
+                        });
+                        return;
+                    }
+                }
+
                 // ── Platform.<NS>.<method>() ──────────────────────────────────
                 if (
                     callee.object.type === 'MemberExpression' &&

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

@@ -4,39 +4,51 @@
  * Flags ES6+ syntax features that are not supported by SFMC's legacy
  * ECMAScript engine. These features cause runtime errors in SFMC.
  *
- * Auto-fix: let/const declarations are rewritten to var (safe, 1:1 swap per
- * Mateusz Dąbrowski's SSJS style guide).
- *
- * Suggestions:
- *   - nullish coalescing (??) → replace with ||
+ * Auto-fix:
+ *   - let/const declarations → var
+ *   - nullish coalescing (??) → || (semantics differ for 0, '', false)
  *   - direct object literal return → extract to variable
  */
 
 import { unsupportedByNodeType } from 'ssjs-data';
 
-// Features that can be safely auto-fixed without changing semantics.
 const AUTO_FIX = {
     LetDeclaration: (node) => (fixer) =>
-        // "let" is 3 chars; the keyword starts at node.range[0].
         fixer.replaceTextRange([node.range[0], node.range[0] + 3], 'var'),
     ConstDeclaration: (node) => (fixer) =>
-        // "const" is 5 chars.
         fixer.replaceTextRange([node.range[0], node.range[0] + 5], 'var'),
 };
 
+function nullishCoalescingFix(context, node) {
+    return (fixer) => {
+        const src = context.sourceCode.getText();
+        const between = src.slice(node.left.range[1], node.right.range[0]);
+        const offset = between.indexOf('??');
+        if (offset === -1) {
+            return null;
+        }
+        const start = node.left.range[1] + offset;
+        return fixer.replaceTextRange([start, start + 2], '||');
+    };
+}
+
+function directObjectReturnFix(context, node) {
+    return (fixer) => {
+        const objText = context.sourceCode.getText(node.argument);
+        const indent = ' '.repeat(node.loc.start.column);
+        return fixer.replaceText(node, `var _result = ${objText};\n${indent}return _result;`);
+    };
+}
+
 export default {
     meta: {
         type: 'problem',
         fixable: 'code',
-        hasSuggestions: true,
         docs: {
             description: 'Disallow ES6+ syntax features not supported by the SFMC SSJS engine',
         },
         messages: {
             unsupported: '{{label}} are not supported in SFMC SSJS. {{suggestion}}',
-            suggestLogicalOr:
-                "Replace ?? with || (note: semantics differ for falsy values like 0, '', and false)",
-            suggestVarReturn: 'Assign the object to a variable, then return the variable',
         },
         schema: [
             {
@@ -83,38 +95,9 @@ export default {
                     if (entry.feature in AUTO_FIX) {
                         report.fix = AUTO_FIX[entry.feature](node);
                     } else if (entry.feature === 'NullishCoalescing') {
-                        report.suggest = [
-                            {
-                                messageId: 'suggestLogicalOr',
-                                fix(fixer) {
-                                    const src = context.sourceCode.getText();
-                                    const between = src.slice(
-                                        node.left.range[1],
-                                        node.right.range[0],
-                                    );
-                                    const offset = between.indexOf('??');
-                                    if (offset === -1) {
-                                        return null;
-                                    }
-                                    const start = node.left.range[1] + offset;
-                                    return fixer.replaceTextRange([start, start + 2], '||');
-                                },
-                            },
-                        ];
+                        report.fix = nullishCoalescingFix(context, node);
                     } else if (entry.feature === 'DirectObjectReturn') {
-                        report.suggest = [
-                            {
-                                messageId: 'suggestVarReturn',
-                                fix(fixer) {
-                                    const objText = context.sourceCode.getText(node.argument);
-                                    const indent = ' '.repeat(node.loc.start.column);
-                                    return fixer.replaceText(
-                                        node,
-                                        `var _result = ${objText};\n${indent}return _result;`,
-                                    );
-                                },
-                            },
-                        ];
+                        report.fix = directObjectReturnFix(context, node);
                     }
 
                     context.report(report);