eslint-plugin-sfmc 2.0.1 → 2.1.1

package/docs/rules/amp/function-arity.md

@@ -12,6 +12,8 @@
 
 AMPscript functions have fixed required and optional argument counts documented in the Salesforce catalog. Calling a function with too few arguments causes a runtime error. Calling it with too many can silently truncate or fail. This rule validates every call against the known min/max argument counts.
 
+Several AMPscript functions are variadic: their trailing arguments repeat in fixed-size groups (for example `Concat` repeats a single value, while the DataExtension `UpdateData`/`UpsertData` family repeats column/value pairs). For these functions the catalog carries a `repeat` model describing where the repeating block starts, how many arguments form one group, and — for the Update/Upsert family — which earlier argument dictates how many search pairs precede the update pairs. This rule additionally reports `incompleteGroup` when the trailing arguments do not form complete groups.
+
 ## Settings
 
 | Setting | Values | Default |
@@ -32,6 +34,9 @@ This rule has no configuration options.
 
   /* Format accepts at most 3 arguments */
   set @val = Format(@num, "0.00", "en-US", "extra")
+
+  /* UpdateData: one search pair, then an incomplete update group (odd trailing args) */
+  UpdateData("MyDE", 1, "Key", @key, "Col", @v, "Orphan")
 ]%%
 ```
 
@@ -42,6 +47,9 @@ This rule has no configuration options.
   var @val
   set @val = Lookup("MyDE", "Value", "Key", @key)
   set @val = Format(@num, "0.00", "en-US")
+
+  /* UpdateData: one search pair + one update pair (complete groups) */
+  UpdateData("MyDE", 1, "Key", @key, "Col", @v)
 ]%%
 ```
 

package/docs/rules/amp/require-variable-declaration.md

@@ -6,7 +6,7 @@
 |---|---|
 | **Type** | `suggestion` |
 | **Default severity** | `off` by default |
-| **Fixable** | — |
+| **Fixable** | **Auto-fix** (`eslint --fix`) |
 
 ## Why This Rule Exists
 
@@ -41,6 +41,16 @@ This rule has no configuration options.
 ]%%
 ```
 
+## Fix
+
+This rule provides an **auto-fix**. Applied by:
+
+- `eslint --fix` on the command line
+- **Fix this issue** / **Fix all auto-fixable problems** in VS Code (requires the [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint))
+- On save via `editor.codeActionsOnSave: { "source.fixAll.eslint": "explicit" }`
+
+What the auto-fix does: inserts `var @variableName` on the line immediately before the first `set` that uses an undeclared `@variable`. Only the first occurrence of each variable receives a fix in a single `--fix` pass to avoid duplicate `var` lines.
+
 ## When to Disable
 
 This rule is off by default because undeclared `set` is valid AMPscript. Enable it for teams that want to enforce a strict declaration-first style.

package/docs/rules/ssjs/cache-loop-length.md

@@ -6,7 +6,7 @@
 |---|---|
 | **Type** | `suggestion` |
 | **Default severity** | `warn` in `recommended`; `error` in `strict` |
-| **Fixable** | **Suggestion** (manual, via VS Code lightbulb) |
+| **Fixable** | **Auto-fix** (`eslint --fix`) |
 
 ## Why This Rule Exists
 
@@ -44,12 +44,13 @@ for (var i = 0, _len = items.length; i < _len; i++) {
 
 ## Fix
 
-This rule provides a **suggestion** (not applied automatically). To apply it:
+This rule provides an **auto-fix**. Applied by:
 
-- Click the **lightbulb** / press `Ctrl+.` on the flagged code in VS Code (requires the [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint))
-- `eslint --fix` does **not** apply suggestions (`--fix-type suggestion` filters fixable rules by rule category, it does **not** apply `hasSuggestions` suggestions)
+- `eslint --fix` on the command line
+- **Fix this issue** / **Fix all auto-fixable problems** in VS Code (requires the [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint))
+- On save via `editor.codeActionsOnSave: { "source.fixAll.eslint": "explicit" }`
 
-What the suggestion does: appends `, _len = arr.length` to the last declarator in the `for` loop initialiser and replaces `arr.length` in the test condition with `_len`. The suggestion is only offered when the loop `init` is a `var` declaration (the typical case).
+What the auto-fix does: appends `, _len = arr.length` to the last declarator in the `for` loop initialiser and replaces `arr.length` in the test condition with `_len`. The fix is only applied when the loop `init` is a `var` declaration (the typical case). Loops with other init forms (for example `for (i = 0; i < arr.length; i++)`) are still reported but not auto-fixed.
 
 ## When to Disable
 

package/docs/rules/ssjs/no-property-call.md

@@ -6,7 +6,7 @@ Calling them with parentheses `()` is a runtime error — they must be accessed
 The rule is fixable:
 
 - **No-arg calls** (`Property()`) → removes the `()` on both `Request` and `Response` properties.
-- **Single-arg calls on `Platform.Response.*`** (`ContentType("text/html")`) → rewrites to an assignment (`= value`), because those two properties are read/write.
+- **Single-arg calls on `Platform.Response.*`** (`ContentType("text/html")`) → rewrites to an assignment (`= value`), including when the call appears in a comma (`SequenceExpression`) expression.
 - **Any-arg calls on `Platform.Request.*`** → reported as an error with no auto-fix, because `Request` properties are read-only.
 
 ## Properties affected
@@ -64,6 +64,12 @@ Platform.Response.ContentType = "application/json";
 Platform.Response.CharacterSet = "UTF-8";
 ```
 
+Auto-fix also applies inside comma expressions:
+
+```js
+Platform.Response.CharacterSet = "UTF-8", Platform.Response.Write("ok");
+```
+
 ### ❌ Incorrect — attempting to set a read-only `Platform.Request` property (no fix)
 
 ```js

package/docs/rules/ssjs/no-unsupported-syntax.md

@@ -6,7 +6,7 @@
 |---|---|
 | **Type** | `problem` |
 | **Default severity** | `error` in `recommended` and `strict` |
-| **Fixable** | **Auto-fix** for `let`/`const`; **Suggestion** for `??` |
+| **Fixable** | **Auto-fix** for `let`/`const`, `??`, and direct object `return` |
 
 ## Why This Rule Exists
 
@@ -49,22 +49,19 @@ var value = (obj && obj.prop !== null && obj.prop !== undefined) ? obj.prop : "d
 
 ## Fix
 
-**Auto-fix** for `let` and `const` declarations. Applied by:
+This rule provides **auto-fix** for selected features. Applied by:
 
 - `eslint --fix` on the command line
 - **Fix this issue** / **Fix all auto-fixable problems** in VS Code (requires the [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint))
 - On save via `editor.codeActionsOnSave: { "source.fixAll.eslint": "explicit" }`
 
-What the auto-fix does: replaces the `let` or `const` keyword with `var`, leaving the rest of the declaration unchanged.
+What the auto-fix does:
 
----
+- **`let` / `const` declarations** — replaces the keyword with `var`, leaving the rest of the declaration unchanged.
+- **Nullish coalescing (`??`)** — replaces `??` with `||`. Note that `||` has different semantics — it also treats `0`, `""`, and `false` as falsy, unlike `??` which only replaces `null` and `undefined`.
+- **Direct object literal `return`** — rewrites `return { … }` to assign the object to a temporary `var _result` and then `return _result`.
 
-**Suggestion** for nullish coalescing (`??`). Applied by:
-
-- Click the **lightbulb** / press `Ctrl+.` on the flagged code in VS Code (requires the ESLint extension)
-- `eslint --fix` does **not** apply suggestions (`--fix-type suggestion` filters fixable rules by rule category, it does **not** apply `hasSuggestions` suggestions)
-
-What the suggestion does: replaces `??` with `||`. Note that `||` has different semantics — it also treats `0`, `""`, and `false` as falsy, unlike `??` which only replaces `null` and `undefined`.
+Other unsupported features (arrow functions, template literals, classes, etc.) have no auto-fix.
 
 ## Configuration Example
 

package/docs/rules/ssjs/require-hasownproperty.md

@@ -6,7 +6,7 @@
 |---|---|
 | **Type** | `suggestion` |
 | **Default severity** | `warn` in `recommended`; `error` in `strict` |
-| **Fixable** | **Suggestion** (manual, via VS Code lightbulb) |
+| **Fixable** | **Auto-fix** (`eslint --fix`) |
 
 ## Why This Rule Exists
 
@@ -42,12 +42,13 @@ for (var key in myObject) {
 
 ## Fix
 
-This rule provides a **suggestion** (not applied automatically). To apply it:
+This rule provides an **auto-fix**. Applied by:
 
-- Click the **lightbulb** / press `Ctrl+.` on the flagged code in VS Code (requires the [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint))
-- `eslint --fix` does **not** apply suggestions (`--fix-type suggestion` filters fixable rules by rule category, it does **not** apply `hasSuggestions` suggestions)
+- `eslint --fix` on the command line
+- **Fix this issue** / **Fix all auto-fixable problems** in VS Code (requires the [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint))
+- On save via `editor.codeActionsOnSave: { "source.fixAll.eslint": "explicit" }`
 
-What the suggestion does: wraps the entire loop body in an `if (obj.hasOwnProperty(key)) { … }` guard. When the body is already a block statement, the existing content is preserved inside the new `if`; when it is a single statement, a new block is created around it.
+What the auto-fix does: wraps the entire loop body in an `if (obj.hasOwnProperty(key)) { … }` guard. When the body is already a block statement, the existing content is preserved inside the new `if`; when it is a single statement, a new block is created around it.
 
 ## When to Disable
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-sfmc",
-    "version": "2.0.1",
+    "version": "2.1.1",
     "description": "ESLint plugin for Salesforce Marketing Cloud — AMPscript and Server-Side JavaScript (SSJS)",
     "type": "module",
     "main": "src/index.js",
@@ -32,7 +32,7 @@
         "sfmc"
     ],
     "dependencies": {
-        "ampscript-data": "^1.0.0",
+        "ampscript-data": "^2.0.1",
         "ampscript-parser": "^0.1.3",
         "ssjs-data": "^0.4.0"
     },
@@ -40,7 +40,8 @@
         "eslint": ">=9.0.0"
     },
     "scripts": {
-        "test": "node --test tests/rules.test.js && node --test tests/fixtures.test.mjs",
+        "test": "node --test tests/rules.test.js && node --test tests/fixtures.test.mjs && node --test tests/autofix-manual.test.mjs",
+        "test:autofix-manual": "node --test tests/autofix-manual.test.mjs",
         "test:fixtures": "node --test tests/fixtures.test.mjs",
         "test:fixtures:update": "node --test tests/fixtures.test.mjs -- --update-snapshots",
         "lint": "eslint .",

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/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-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);

package/src/rules/ssjs/require-hasownproperty.js

@@ -4,22 +4,20 @@
  * In for-in loops, require a hasOwnProperty guard to avoid iterating
  * over inherited properties (like _type) that SSJS objects may have.
  *
- * Suggestion: wraps the existing loop body in an
+ * Auto-fix: wraps the existing loop body in an
  * `if (obj.hasOwnProperty(key)) { ... }` guard.
  */
 
 export default {
     meta: {
         type: 'suggestion',
-        hasSuggestions: true,
+        fixable: 'code',
         docs: {
             description: 'Require hasOwnProperty guard in for-in loops',
         },
         messages: {
             missingGuard:
                 'Add a hasOwnProperty check inside for-in loops to avoid iterating over inherited properties.',
-            suggestAddGuard:
-                'Wrap the loop body in an `if ({{obj}}.hasOwnProperty({{key}})) { ... }` guard',
         },
         schema: [],
     },
@@ -41,35 +39,58 @@ export default {
                     const keyName = getKeyName(node.left);
                     const objText = context.sourceCode.getText(node.right);
 
+                    if (!keyName) {
+                        context.report({
+                            node,
+                            messageId: 'missingGuard',
+                        });
+                        return;
+                    }
+
                     context.report({
                         node,
                         messageId: 'missingGuard',
-                        suggest: keyName
-                            ? [
-                                  {
-                                      messageId: 'suggestAddGuard',
-                                      data: { obj: objText, key: keyName },
-                                      fix(fixer) {
-                                          if (body.type === 'BlockStatement') {
-                                              // Wrap the inner content of the existing block.
-                                              const inner = context.sourceCode
-                                                  .getText(body)
-                                                  .slice(1, -1);
-                                              return fixer.replaceText(
-                                                  body,
-                                                  `{ if (${objText}.hasOwnProperty(${keyName})) {${inner}} }`,
-                                              );
-                                          }
-                                          // Single-statement body — create a new block with guard.
-                                          const stmtText = context.sourceCode.getText(body);
-                                          return fixer.replaceText(
-                                              body,
-                                              `{ if (${objText}.hasOwnProperty(${keyName})) { ${stmtText} } }`,
-                                          );
-                                      },
-                                  },
-                              ]
-                            : [],
+                        fix(fixer) {
+                            const sourceCode = context.sourceCode;
+                            const innerStmts = body.type === 'BlockStatement' ? body.body : [body];
+
+                            // Single-line loops keep compact output to avoid reformatting
+                            // code the author intentionally wrote on one line.
+                            const isSingleLine = node.loc.start.line === node.loc.end.line;
+                            if (isSingleLine) {
+                                const compactBody = innerStmts
+                                    .map((stmt) => sourceCode.getText(stmt))
+                                    .join(' ');
+                                return fixer.replaceText(
+                                    body,
+                                    `{ if (${objText}.hasOwnProperty(${keyName})) { ${compactBody} } }`,
+                                );
+                            }
+
+                            // Multi-line loops: emit a properly-indented guard block.
+                            const loopLine = sourceCode.lines[node.loc.start.line - 1] ?? '';
+                            const baseIndent = (loopLine.match(/^[\t ]*/) ?? [''])[0];
+                            const firstStmt = innerStmts[0];
+                            const firstStmtLine = firstStmt
+                                ? (sourceCode.lines[firstStmt.loc.start.line - 1] ?? '')
+                                : '';
+                            const firstStmtIndent = (firstStmtLine.match(/^[\t ]*/) ?? [''])[0];
+                            const unit =
+                                firstStmtIndent.length > baseIndent.length
+                                    ? firstStmtIndent.slice(baseIndent.length)
+                                    : '    ';
+                            const guardIndent = baseIndent + unit;
+                            const stmtIndent = guardIndent + unit;
+
+                            const guardedBody = innerStmts
+                                .map((stmt) => `${stmtIndent}${sourceCode.getText(stmt)}`)
+                                .join('\n');
+
+                            return fixer.replaceText(
+                                body,
+                                `{\n${guardIndent}if (${objText}.hasOwnProperty(${keyName})) {\n${guardedBody}\n${guardIndent}}\n${baseIndent}}`,
+                            );
+                        },
                     });
                 }
             },